| /* |
| * Copyright © 2010 Intel 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 <cstdlib> |
| #include <cstdio> |
| #include <cstdarg> |
| |
| #include "main/core.h" |
| #include "glsl_symbol_table.h" |
| #include "glsl_parser_extras.h" |
| #include "ir.h" |
| #include "program.h" |
| #include "program/hash_table.h" |
| #include "linker.h" |
| |
| static ir_function_signature * |
| find_matching_signature(const char *name, const exec_list *actual_parameters, |
| gl_shader **shader_list, unsigned num_shaders); |
| |
| class call_link_visitor : public ir_hierarchical_visitor { |
| public: |
| call_link_visitor(gl_shader_program *prog, gl_shader *linked, |
| gl_shader **shader_list, unsigned num_shaders) |
| { |
| this->prog = prog; |
| this->shader_list = shader_list; |
| this->num_shaders = num_shaders; |
| this->success = true; |
| this->linked = linked; |
| |
| this->locals = hash_table_ctor(0, hash_table_pointer_hash, |
| hash_table_pointer_compare); |
| } |
| |
| ~call_link_visitor() |
| { |
| hash_table_dtor(this->locals); |
| } |
| |
| virtual ir_visitor_status visit(ir_variable *ir) |
| { |
| hash_table_insert(locals, ir, ir); |
| return visit_continue; |
| } |
| |
| virtual ir_visitor_status visit_enter(ir_call *ir) |
| { |
| /* If ir is an ir_call from a function that was imported from another |
| * shader callee will point to an ir_function_signature in the original |
| * shader. In this case the function signature MUST NOT BE MODIFIED. |
| * Doing so will modify the original shader. This may prevent that |
| * shader from being linkable in other programs. |
| */ |
| const ir_function_signature *const callee = ir->get_callee(); |
| assert(callee != NULL); |
| const char *const name = callee->function_name(); |
| |
| /* Determine if the requested function signature already exists in the |
| * final linked shader. If it does, use it as the target of the call. |
| */ |
| ir_function_signature *sig = |
| find_matching_signature(name, &callee->parameters, &linked, 1); |
| if (sig != NULL) { |
| ir->set_callee(sig); |
| return visit_continue; |
| } |
| |
| /* Try to find the signature in one of the other shaders that is being |
| * linked. If it's not found there, return an error. |
| */ |
| sig = find_matching_signature(name, &ir->actual_parameters, shader_list, |
| num_shaders); |
| if (sig == NULL) { |
| /* FINISHME: Log the full signature of unresolved function. |
| */ |
| linker_error_printf(this->prog, "unresolved reference to function " |
| "`%s'\n", name); |
| this->success = false; |
| return visit_stop; |
| } |
| |
| /* Find the prototype information in the linked shader. Generate any |
| * details that may be missing. |
| */ |
| ir_function *f = linked->symbols->get_function(name); |
| if (f == NULL) |
| f = new(linked) ir_function(name); |
| |
| ir_function_signature *linked_sig = |
| f->exact_matching_signature(&callee->parameters); |
| if (linked_sig == NULL) { |
| linked_sig = new(linked) ir_function_signature(callee->return_type); |
| f->add_signature(linked_sig); |
| } |
| |
| /* At this point linked_sig and called may be the same. If ir is an |
| * ir_call from linked then linked_sig and callee will be |
| * ir_function_signatures that have no definitions (is_defined is false). |
| */ |
| assert(!linked_sig->is_defined); |
| assert(linked_sig->body.is_empty()); |
| |
| /* Create an in-place clone of the function definition. This multistep |
| * process introduces some complexity here, but it has some advantages. |
| * The parameter list and the and function body are cloned separately. |
| * The clone of the parameter list is used to prime the hashtable used |
| * to replace variable references in the cloned body. |
| * |
| * The big advantage is that the ir_function_signature does not change. |
| * This means that we don't have to process the rest of the IR tree to |
| * patch ir_call nodes. In addition, there is no way to remove or |
| * replace signature stored in a function. One could easily be added, |
| * but this avoids the need. |
| */ |
| struct hash_table *ht = hash_table_ctor(0, hash_table_pointer_hash, |
| hash_table_pointer_compare); |
| exec_list formal_parameters; |
| foreach_list_const(node, &sig->parameters) { |
| const ir_instruction *const original = (ir_instruction *) node; |
| assert(const_cast<ir_instruction *>(original)->as_variable()); |
| |
| ir_instruction *copy = original->clone(linked, ht); |
| formal_parameters.push_tail(copy); |
| } |
| |
| linked_sig->replace_parameters(&formal_parameters); |
| |
| foreach_list_const(node, &sig->body) { |
| const ir_instruction *const original = (ir_instruction *) node; |
| |
| ir_instruction *copy = original->clone(linked, ht); |
| linked_sig->body.push_tail(copy); |
| } |
| |
| linked_sig->is_defined = true; |
| hash_table_dtor(ht); |
| |
| /* Patch references inside the function to things outside the function |
| * (i.e., function calls and global variables). |
| */ |
| linked_sig->accept(this); |
| |
| ir->set_callee(linked_sig); |
| |
| return visit_continue; |
| } |
| |
| virtual ir_visitor_status visit(ir_dereference_variable *ir) |
| { |
| if (hash_table_find(locals, ir->var) == NULL) { |
| /* The non-function variable must be a global, so try to find the |
| * variable in the shader's symbol table. If the variable is not |
| * found, then it's a global that *MUST* be defined in the original |
| * shader. |
| */ |
| ir_variable *var = linked->symbols->get_variable(ir->var->name); |
| if (var == NULL) { |
| /* Clone the ir_variable that the dereference already has and add |
| * it to the linked shader. |
| */ |
| var = ir->var->clone(linked, NULL); |
| linked->symbols->add_variable(var); |
| linked->ir->push_head(var); |
| } |
| |
| ir->var = var; |
| } |
| |
| return visit_continue; |
| } |
| |
| /** Was function linking successful? */ |
| bool success; |
| |
| private: |
| /** |
| * Shader program being linked |
| * |
| * This is only used for logging error messages. |
| */ |
| gl_shader_program *prog; |
| |
| /** List of shaders available for linking. */ |
| gl_shader **shader_list; |
| |
| /** Number of shaders available for linking. */ |
| unsigned num_shaders; |
| |
| /** |
| * Final linked shader |
| * |
| * This is used two ways. It is used to find global variables in the |
| * linked shader that are accessed by the function. It is also used to add |
| * global variables from the shader where the function originated. |
| */ |
| gl_shader *linked; |
| |
| /** |
| * Table of variables local to the function. |
| */ |
| hash_table *locals; |
| }; |
| |
| |
| /** |
| * Searches a list of shaders for a particular function definition |
| */ |
| ir_function_signature * |
| find_matching_signature(const char *name, const exec_list *actual_parameters, |
| gl_shader **shader_list, unsigned num_shaders) |
| { |
| for (unsigned i = 0; i < num_shaders; i++) { |
| ir_function *const f = shader_list[i]->symbols->get_function(name); |
| |
| if (f == NULL) |
| continue; |
| |
| ir_function_signature *sig = f->matching_signature(actual_parameters); |
| |
| if ((sig == NULL) || !sig->is_defined) |
| continue; |
| |
| return sig; |
| } |
| |
| return NULL; |
| } |
| |
| |
| bool |
| link_function_calls(gl_shader_program *prog, gl_shader *main, |
| gl_shader **shader_list, unsigned num_shaders) |
| { |
| call_link_visitor v(prog, main, shader_list, num_shaders); |
| |
| v.run(main->ir); |
| return v.success; |
| } |