| /* |
| * Copyright © 2024 Valve Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| * DEALINGS IN THE SOFTWARE. |
| */ |
| |
| #include "gl_nir_linker.h" |
| #include "linker_util.h" |
| #include "program/symbol_table.h" |
| #include "util/hash_table.h" |
| #include "main/shader_types.h" |
| |
| struct function_sig { |
| nir_function *func; |
| |
| struct list_head node; |
| }; |
| |
| typedef enum { |
| PARAMETER_LIST_NO_MATCH, |
| PARAMETER_LIST_EXACT_MATCH, |
| PARAMETER_LIST_INEXACT_MATCH /* Match requires implicit conversion. */ |
| } parameter_list_match_t; |
| |
| /** |
| * Check if two parameter lists match. |
| * |
| * list_a Parameters of the function definition. |
| * list_b Actual parameters passed to the function. |
| */ |
| static parameter_list_match_t |
| parameter_lists_match(bool has_implicit_conversions, |
| bool has_implicit_int_to_uint_conversion, |
| nir_parameter *list_a, unsigned num_params_a, |
| nir_parameter *list_b, unsigned num_params_b) |
| { |
| /* The lists have different length and by definition do not match. */ |
| if (num_params_a != num_params_b) |
| return PARAMETER_LIST_NO_MATCH; |
| |
| nir_parameter *param_a; |
| nir_parameter *param_b; |
| |
| /* This is set to true if there is an inexact match requiring an implicit |
| * conversion. */ |
| bool inexact_match = false; |
| |
| for (int i = 0; i < num_params_a; i++) { |
| param_a = &list_a[i]; |
| param_b = &list_b[i]; |
| |
| if (param_a->type == param_b->type) |
| continue; |
| |
| /* Try to find an implicit conversion from actual to param. */ |
| inexact_match = true; |
| |
| switch (param_a->mode) { |
| case nir_var_function_in: |
| if (param_a->implicit_conversion_prohibited || |
| !_mesa_glsl_can_implicitly_convert(param_b->type, param_a->type, |
| has_implicit_conversions, |
| has_implicit_int_to_uint_conversion)) |
| return PARAMETER_LIST_NO_MATCH; |
| break; |
| |
| case nir_var_function_out: |
| if (!_mesa_glsl_can_implicitly_convert(param_a->type, param_b->type, |
| has_implicit_conversions, |
| has_implicit_int_to_uint_conversion)) |
| return PARAMETER_LIST_NO_MATCH; |
| break; |
| |
| case nir_var_function_inout: |
| /* Since there are no bi-directional automatic conversions (e.g., |
| * there is int -> float but no float -> int), inout parameters must |
| * be exact matches. |
| */ |
| return PARAMETER_LIST_NO_MATCH; |
| |
| default: |
| assert(false); |
| return PARAMETER_LIST_NO_MATCH; |
| } |
| } |
| |
| if (inexact_match) |
| return PARAMETER_LIST_INEXACT_MATCH; |
| else |
| return PARAMETER_LIST_EXACT_MATCH; |
| } |
| |
| |
| /* Classes of parameter match, sorted (mostly) best matches first. |
| * See is_better_parameter_match() below for the exceptions. |
| * */ |
| typedef enum { |
| PARAMETER_EXACT_MATCH, |
| PARAMETER_FLOAT_TO_DOUBLE, |
| PARAMETER_INT_TO_FLOAT, |
| PARAMETER_INT_TO_DOUBLE, |
| PARAMETER_OTHER_CONVERSION, |
| } parameter_match_t; |
| |
| |
| static parameter_match_t |
| get_parameter_match_type(const nir_parameter *param, |
| const nir_parameter *actual) |
| { |
| const struct glsl_type *from_type; |
| const struct glsl_type *to_type; |
| |
| if (param->mode == nir_var_function_out) { |
| from_type = param->type; |
| to_type = actual->type; |
| } else { |
| from_type = actual->type; |
| to_type = param->type; |
| } |
| |
| if (from_type == to_type) |
| return PARAMETER_EXACT_MATCH; |
| |
| if (glsl_type_is_double(to_type)) { |
| if (glsl_type_is_float(from_type)) |
| return PARAMETER_FLOAT_TO_DOUBLE; |
| return PARAMETER_INT_TO_DOUBLE; |
| } |
| |
| if (glsl_type_is_float(to_type)) |
| return PARAMETER_INT_TO_FLOAT; |
| |
| /* int -> uint and any other oddball conversions */ |
| return PARAMETER_OTHER_CONVERSION; |
| } |
| |
| /* From section 6.1 of the GLSL 4.00 spec (and the ARB_gpu_shader5 spec): |
| * |
| * 1. An exact match is better than a match involving any implicit |
| * conversion. |
| * |
| * 2. A match involving an implicit conversion from float to double |
| * is better than match involving any other implicit conversion. |
| * |
| * [XXX: Not in GLSL 4.0: Only in ARB_gpu_shader5: |
| * 3. A match involving an implicit conversion from either int or uint |
| * to float is better than a match involving an implicit conversion |
| * from either int or uint to double.] |
| * |
| * If none of the rules above apply to a particular pair of conversions, |
| * neither conversion is considered better than the other. |
| * |
| * -- |
| * |
| * Notably, the int->uint conversion is *not* considered to be better |
| * or worse than int/uint->float or int/uint->double. |
| */ |
| static bool |
| is_better_parameter_match(parameter_match_t a_match, |
| parameter_match_t b_match) |
| { |
| if (a_match >= PARAMETER_INT_TO_FLOAT && b_match == PARAMETER_OTHER_CONVERSION) |
| return false; |
| |
| return a_match < b_match; |
| } |
| |
| /* From section 6.1 of the GLSL 4.00 spec (and the ARB_gpu_shader5 spec): |
| * |
| * "A function definition A is considered a better |
| * match than function definition B if: |
| * |
| * * for at least one function argument, the conversion for that argument |
| * in A is better than the corresponding conversion in B; and |
| * |
| * * there is no function argument for which the conversion in B is better |
| * than the corresponding conversion in A. |
| * |
| * If a single function definition is considered a better match than every |
| * other matching function definition, it will be used. Otherwise, a |
| * semantic error occurs and the shader will fail to compile." |
| */ |
| static bool |
| is_best_inexact_overload(nir_parameter *actual_parameters, |
| unsigned num_parameters, |
| nir_function **matches, int num_matches, |
| nir_function *sig) |
| { |
| |
| for (nir_function **other = matches; other < matches + num_matches; other++) { |
| if (*other == sig) |
| continue; |
| |
| nir_parameter *node_a = sig->params; |
| nir_parameter *node_b = (*other)->params; |
| |
| bool better_for_some_parameter = false; |
| |
| for (unsigned i = 0; i < num_parameters; i++) { |
| parameter_match_t a_match = |
| get_parameter_match_type(&node_a[i], &actual_parameters[i]); |
| parameter_match_t b_match = |
| get_parameter_match_type(&node_b[i], &actual_parameters[i]); |
| |
| if (is_better_parameter_match(a_match, b_match)) |
| better_for_some_parameter = true; |
| |
| if (is_better_parameter_match(b_match, a_match)) |
| return false; /* B is better for this parameter */ |
| } |
| |
| if (!better_for_some_parameter) |
| return false; /* A must be better than B for some parameter */ |
| } |
| |
| return true; |
| } |
| |
| static nir_function * |
| choose_best_inexact_overload(nir_parameter *actual_parameters, |
| unsigned num_parameters, |
| nir_function **matches, int num_matches, |
| bool has_choose_best_inexact_overload) |
| { |
| if (num_matches == 0) |
| return NULL; |
| |
| if (num_matches == 1) |
| return *matches; |
| |
| if (!has_choose_best_inexact_overload) |
| return NULL; |
| |
| for (nir_function **sig = matches; sig < matches + num_matches; sig++) { |
| if (is_best_inexact_overload(actual_parameters, num_parameters, |
| matches, num_matches, *sig)) |
| return *sig; |
| } |
| |
| /* no best candidate */ |
| return NULL; |
| } |
| |
| static nir_function * |
| find_matching_signature(struct list_head *f_list, |
| nir_parameter *parameters, |
| unsigned num_parameters, |
| bool has_implicit_conversions, |
| bool has_implicit_int_to_uint_conversion) |
| { |
| nir_function **inexact_matches = NULL; |
| nir_function **inexact_matches_temp; |
| nir_function *match = NULL; |
| int num_inexact_matches = 0; |
| |
| /* From page 42 (page 49 of the PDF) of the GLSL 1.20 spec: |
| * |
| * "If an exact match is found, the other signatures are ignored, and |
| * the exact match is used. Otherwise, if no exact match is found, then |
| * the implicit conversions in Section 4.1.10 "Implicit Conversions" will |
| * be applied to the calling arguments if this can make their types match |
| * a signature. In this case, it is a semantic error if there are |
| * multiple ways to apply these conversions to the actual arguments of a |
| * call such that the call can be made to match multiple signatures." |
| */ |
| list_for_each_entry(struct function_sig, sig, f_list, node) { |
| switch (parameter_lists_match(has_implicit_conversions, |
| has_implicit_int_to_uint_conversion, |
| sig->func->params, sig->func->num_params, |
| parameters, num_parameters)) { |
| case PARAMETER_LIST_EXACT_MATCH: |
| free(inexact_matches); |
| return sig->func; |
| case PARAMETER_LIST_INEXACT_MATCH: |
| /* Subroutine signatures must match exactly */ |
| if (sig->func->is_subroutine) |
| continue; |
| |
| inexact_matches_temp = (nir_function **) |
| realloc(inexact_matches, |
| sizeof(*inexact_matches) * |
| (num_inexact_matches + 1)); |
| |
| inexact_matches = inexact_matches_temp; |
| inexact_matches[num_inexact_matches++] = sig->func; |
| continue; |
| case PARAMETER_LIST_NO_MATCH: |
| continue; |
| default: |
| assert(false); |
| return NULL; |
| } |
| } |
| |
| match = choose_best_inexact_overload(parameters, num_parameters, |
| inexact_matches, num_inexact_matches, |
| has_implicit_int_to_uint_conversion); |
| |
| free(inexact_matches); |
| return match; |
| } |
| |
| static nir_function * |
| clone_function(struct hash_table *remap_table, |
| const nir_function *fxn, nir_shader *ns) |
| { |
| nir_function *nfxn = nir_function_clone(ns, fxn); |
| /* Needed for call instructions */ |
| _mesa_hash_table_insert(remap_table, fxn, nfxn); |
| |
| return nfxn; |
| } |
| |
| bool |
| gl_nir_link_function_calls(struct gl_shader_program *prog, |
| struct gl_shader *main, |
| struct gl_linked_shader *linked_sh, |
| struct gl_shader **shader_list, |
| unsigned num_shaders) |
| { |
| void *mem_ctx = ralloc_context(NULL); |
| struct hash_table *var_lookup = _mesa_string_hash_table_create(mem_ctx); |
| struct hash_table *func_lookup = _mesa_string_hash_table_create(mem_ctx); |
| struct hash_table *remap_table = _mesa_pointer_hash_table_create(mem_ctx); |
| |
| nir_foreach_variable_in_shader(var, linked_sh->Program->nir) { |
| _mesa_hash_table_insert(var_lookup, var->name, var); |
| } |
| |
| nir_foreach_function(func, linked_sh->Program->nir) { |
| if (!func->impl) |
| continue; |
| |
| struct hash_entry *e = _mesa_hash_table_search(func_lookup, func->name); |
| if (e) { |
| struct list_head *f_list = (struct list_head *) e->data; |
| |
| nir_function *f = find_matching_signature(f_list, func->params, |
| func->num_params, |
| main->has_implicit_conversions, |
| main->has_implicit_int_to_uint_conversion); |
| if (!f) { |
| struct function_sig *func_sig = ralloc(mem_ctx, struct function_sig); |
| func_sig->func = func; |
| list_add(&func_sig->node, f_list); |
| } |
| } else { |
| struct list_head *func_list = ralloc(mem_ctx, struct list_head); |
| list_inithead(func_list); |
| |
| struct function_sig *func_sig = ralloc(mem_ctx, struct function_sig); |
| func_sig->func = func; |
| list_add(&func_sig->node, func_list); |
| _mesa_hash_table_insert(func_lookup, func->name, func_list); |
| } |
| } |
| |
| for (unsigned i = 0; i < num_shaders; i++) { |
| /* Skip shader object with main function as we have already cloned the |
| * full shader. |
| */ |
| if (main == shader_list[i]) |
| continue; |
| |
| /* Before cloning the shader check the lookup table to see if globals |
| * have already been seen in a previous shader, if so update the remap |
| * table. |
| */ |
| nir_foreach_variable_in_shader(var, shader_list[i]->nir) { |
| struct hash_entry *e = |
| _mesa_hash_table_search(var_lookup, var->name); |
| if (e) { |
| _mesa_hash_table_insert(remap_table, var, e->data); |
| |
| nir_variable *m_var = (nir_variable *) e->data; |
| if (glsl_type_is_array(var->type)) { |
| /* It is possible to have a global array declared in multiple |
| * shaders without a size. The array is implicitly sized by |
| * the maximal access to it in *any* shader. Because of this, |
| * we need to track the maximal access to the array as linking |
| * pulls more functions in that access the array. |
| */ |
| m_var->data.max_array_access = |
| MAX2(var->data.max_array_access, |
| m_var->data.max_array_access); |
| |
| if (glsl_array_size(m_var->type) == 0 && |
| glsl_array_size(var->type) != 0) |
| m_var->type = var->type; |
| } |
| if (glsl_without_array(var->type) == var->interface_type) { |
| /* Similarly, we need implicit sizes of arrays within interface |
| * blocks to be sized by the maximal access in *any* shader. |
| */ |
| int *linked_max_ifc_array_access = m_var->max_ifc_array_access; |
| int *ir_max_ifc_array_access = var->max_ifc_array_access; |
| |
| assert(linked_max_ifc_array_access != NULL); |
| assert(ir_max_ifc_array_access != NULL); |
| |
| for (unsigned j = 0; j < var->interface_type->length; j++) { |
| linked_max_ifc_array_access[j] = |
| MAX2(linked_max_ifc_array_access[j], |
| ir_max_ifc_array_access[j]); |
| } |
| } |
| } else { |
| nir_variable *nvar = |
| nir_variable_clone(var, linked_sh->Program->nir); |
| _mesa_hash_table_insert(remap_table, var, nvar); |
| nir_shader_add_variable(linked_sh->Program->nir, nvar); |
| _mesa_hash_table_insert(var_lookup, var->name, nvar); |
| } |
| } |
| |
| /* Clone functions into our combined shader */ |
| nir_foreach_function(func, shader_list[i]->nir) { |
| nir_function *f = NULL; |
| |
| /* Try to find the signature in one of the shaders that is being |
| * linked. If not found clone the function. |
| */ |
| struct hash_entry *e = _mesa_hash_table_search(func_lookup, func->name); |
| if (e) { |
| struct list_head *f_list = (struct list_head *) e->data; |
| |
| f = find_matching_signature(f_list, func->params, |
| func->num_params, |
| false, |
| false); |
| if (!f) { |
| struct function_sig *func_sig = ralloc(mem_ctx, struct function_sig); |
| f = clone_function(remap_table, func, linked_sh->Program->nir); |
| func_sig->func = f; |
| if (func->impl) |
| list_add(&func_sig->node, f_list); |
| } else { |
| _mesa_hash_table_insert(remap_table, func, f); |
| } |
| } else { |
| struct list_head *func_list = ralloc(mem_ctx, struct list_head); |
| list_inithead(func_list); |
| |
| struct function_sig *func_sig = ralloc(mem_ctx, struct function_sig); |
| f = clone_function(remap_table, func, linked_sh->Program->nir); |
| func_sig->func = f; |
| if (func->impl) |
| list_add(&func_sig->node, func_list); |
| _mesa_hash_table_insert(func_lookup, func->name, func_list); |
| } |
| } |
| |
| /* Now that all functions are cloned we can clone any function |
| * implementations. We can't do this in the previous loop above because |
| * glsl to nir places function declarations next to implementations i.e. |
| * we have lost any predeclared function signatures so we won't always |
| * find them in the remap table until they have all been processed. |
| */ |
| nir_foreach_function(func, shader_list[i]->nir) { |
| if (func->impl) { |
| nir_function_impl *f_impl = |
| nir_function_impl_clone_remap_globals(linked_sh->Program->nir, |
| func->impl, remap_table); |
| |
| struct hash_entry *e = |
| _mesa_hash_table_search(remap_table, func); |
| assert(e); |
| |
| nir_function *f = (nir_function *) e->data; |
| |
| assert(!f->impl); |
| nir_function_set_impl(f, f_impl); |
| } |
| } |
| } |
| |
| /* Now that all shaders have been combined together make sure all function |
| * calls can be resolved. |
| */ |
| nir_foreach_function_impl(impl, linked_sh->Program->nir) { |
| nir_foreach_block(block, impl) { |
| nir_foreach_instr(instr, block) { |
| if (instr->type == nir_instr_type_call) { |
| nir_call_instr *call = nir_instr_as_call(instr); |
| |
| /* If this was already set at compile time don't try to set it |
| * again. |
| */ |
| if (call->callee->impl) |
| continue; |
| |
| struct hash_entry *e = _mesa_hash_table_search(func_lookup, |
| call->callee->name); |
| if (e) { |
| struct list_head *f_list = (struct list_head *) e->data; |
| |
| nir_function *f = |
| find_matching_signature(f_list, call->callee->params, |
| call->callee->num_params, |
| main->has_implicit_conversions, |
| main->has_implicit_int_to_uint_conversion); |
| if (f) |
| call->callee = f; |
| } |
| |
| if (!call->callee->impl) { |
| linker_error(prog, "unresolved reference to function `%s'\n", |
| call->callee->name); |
| ralloc_free(mem_ctx); |
| return false; |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Link all out variables on a single stage which are not |
| * directly used in a shader with the main function. |
| */ |
| if (linked_sh->Stage != MESA_SHADER_FRAGMENT) { |
| for (unsigned i = 0; i < num_shaders; i++) { |
| /* Skip shader object with main function as we have already cloned |
| * the full shader, including shader outputs. |
| */ |
| if (main == shader_list[i]) |
| continue; |
| |
| nir_foreach_shader_out_variable(var, shader_list[i]->nir) { |
| struct hash_entry *e = |
| _mesa_hash_table_search(var_lookup, var->name); |
| if (e) |
| continue; |
| |
| nir_variable *nvar = nir_variable_clone(var, linked_sh->Program->nir); |
| nir_shader_add_variable(linked_sh->Program->nir, nvar); |
| _mesa_hash_table_insert(var_lookup, var->name, var); |
| } |
| } |
| } |
| |
| |
| /* Call fixup deref types as we may have set array sizes above */ |
| nir_fixup_deref_types(linked_sh->Program->nir); |
| |
| ralloc_free(mem_ctx); |
| |
| return true; |
| } |
