0,0 → 1,348 |
/* |
* 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 "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, |
bool use_builtin); |
|
namespace { |
|
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->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, |
ir->use_builtin); |
if (sig != NULL) { |
ir->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, ir->use_builtin); |
if (sig == NULL) { |
/* FINISHME: Log the full signature of unresolved function. |
*/ |
linker_error(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); |
|
/* Add the new function to the linked IR. Put it at the end |
* so that it comes after any global variable declarations |
* that it refers to. |
*/ |
linked->symbols->add_function(f); |
linked->ir->push_tail(f); |
} |
|
ir_function_signature *linked_sig = |
f->exact_matching_signature(NULL, &callee->parameters); |
if ((linked_sig == NULL) |
|| ((linked_sig != NULL) |
&& (linked_sig->is_builtin() != ir->use_builtin))) { |
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_in_list(const ir_instruction, original, &sig->parameters) { |
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); |
|
linked_sig->is_intrinsic = sig->is_intrinsic; |
|
if (sig->is_defined) { |
foreach_in_list(const ir_instruction, original, &sig->body) { |
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->callee = linked_sig; |
|
return visit_continue; |
} |
|
virtual ir_visitor_status visit_leave(ir_call *ir) |
{ |
/* Traverse list of function parameters, and for array parameters |
* propagate max_array_access. Otherwise arrays that are only referenced |
* from inside functions via function parameters will be incorrectly |
* optimized. This will lead to incorrect code being generated (or worse). |
* Do it when leaving the node so the children would propagate their |
* array accesses first. |
*/ |
|
const exec_node *formal_param_node = ir->callee->parameters.get_head(); |
if (formal_param_node) { |
const exec_node *actual_param_node = ir->actual_parameters.get_head(); |
while (!actual_param_node->is_tail_sentinel()) { |
ir_variable *formal_param = (ir_variable *) formal_param_node; |
ir_rvalue *actual_param = (ir_rvalue *) actual_param_node; |
|
formal_param_node = formal_param_node->get_next(); |
actual_param_node = actual_param_node->get_next(); |
|
if (formal_param->type->is_array()) { |
ir_dereference_variable *deref = actual_param->as_dereference_variable(); |
if (deref && deref->var && deref->var->type->is_array()) { |
deref->var->data.max_array_access = |
MAX2(formal_param->data.max_array_access, |
deref->var->data.max_array_access); |
} |
} |
} |
} |
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); |
} else { |
if (var->type->is_array()) { |
/* 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. |
*/ |
var->data.max_array_access = |
MAX2(var->data.max_array_access, |
ir->var->data.max_array_access); |
|
if (var->type->length == 0 && ir->var->type->length != 0) |
var->type = ir->var->type; |
} |
if (var->is_interface_instance()) { |
/* Similarly, we need implicit sizes of arrays within interface |
* blocks to be sized by the maximal access in *any* shader. |
*/ |
unsigned *const linked_max_ifc_array_access = |
var->get_max_ifc_array_access(); |
unsigned *const ir_max_ifc_array_access = |
ir->var->get_max_ifc_array_access(); |
|
assert(linked_max_ifc_array_access != NULL); |
assert(ir_max_ifc_array_access != NULL); |
|
for (unsigned i = 0; i < var->get_interface_type()->length; |
i++) { |
linked_max_ifc_array_access[i] = |
MAX2(linked_max_ifc_array_access[i], |
ir_max_ifc_array_access[i]); |
} |
} |
} |
|
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; |
}; |
|
} /* anonymous namespace */ |
|
/** |
* 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, |
bool use_builtin) |
{ |
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(NULL, actual_parameters, use_builtin); |
|
if ((sig == NULL) || |
(!sig->is_defined && !sig->is_intrinsic)) |
continue; |
|
/* If this function expects to bind to a built-in function and the |
* signature that we found isn't a built-in, keep looking. Also keep |
* looking if we expect a non-built-in but found a built-in. |
*/ |
if (use_builtin != sig->is_builtin()) |
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; |
} |