| /* |
| * 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. |
| */ |
| |
| /** |
| * \file ir_set_program_inouts.cpp |
| * |
| * Sets the inputs_read and outputs_written of Mesa programs. |
| * |
| * Mesa programs (gl_program, not gl_shader_program) have a set of |
| * flags indicating which varyings are read and written. Computing |
| * which are actually read from some sort of backend code can be |
| * tricky when variable array indexing involved. So this pass |
| * provides support for setting inputs_read and outputs_written right |
| * from the GLSL IR. |
| */ |
| |
| #include "ir.h" |
| #include "ir_visitor.h" |
| #include "compiler/glsl_types.h" |
| #include "main/mtypes.h" |
| |
| namespace { |
| |
| class ir_set_program_inouts_visitor : public ir_hierarchical_visitor { |
| public: |
| ir_set_program_inouts_visitor(struct gl_program *prog, |
| gl_shader_stage shader_stage) |
| { |
| this->prog = prog; |
| this->shader_stage = shader_stage; |
| } |
| ~ir_set_program_inouts_visitor() |
| { |
| } |
| |
| virtual ir_visitor_status visit_enter(ir_dereference_array *); |
| virtual ir_visitor_status visit_enter(ir_function_signature *); |
| virtual ir_visitor_status visit_enter(ir_discard *); |
| virtual ir_visitor_status visit_enter(ir_texture *); |
| virtual ir_visitor_status visit(ir_dereference_variable *); |
| |
| private: |
| void mark_whole_variable(ir_variable *var); |
| bool try_mark_partial_variable(ir_variable *var, ir_rvalue *index); |
| |
| struct gl_program *prog; |
| gl_shader_stage shader_stage; |
| }; |
| |
| } /* anonymous namespace */ |
| |
| static inline bool |
| is_shader_inout(ir_variable *var) |
| { |
| return var->data.mode == ir_var_shader_in || |
| var->data.mode == ir_var_shader_out || |
| var->data.mode == ir_var_system_value; |
| } |
| |
| static void |
| mark(struct gl_program *prog, ir_variable *var, int offset, int len, |
| gl_shader_stage stage) |
| { |
| /* As of GLSL 1.20, varyings can only be floats, floating-point |
| * vectors or matrices, or arrays of them. For Mesa programs using |
| * inputs_read/outputs_written, everything but matrices uses one |
| * slot, while matrices use a slot per column. Presumably |
| * something doing a more clever packing would use something other |
| * than inputs_read/outputs_written. |
| */ |
| |
| for (int i = 0; i < len; i++) { |
| assert(var->data.location != -1); |
| |
| int idx = var->data.location + offset + i; |
| bool is_patch_generic = var->data.patch && |
| idx != VARYING_SLOT_TESS_LEVEL_INNER && |
| idx != VARYING_SLOT_TESS_LEVEL_OUTER && |
| idx != VARYING_SLOT_BOUNDING_BOX0 && |
| idx != VARYING_SLOT_BOUNDING_BOX1; |
| GLbitfield64 bitfield; |
| |
| if (is_patch_generic) { |
| assert(idx >= VARYING_SLOT_PATCH0 && idx < VARYING_SLOT_TESS_MAX); |
| bitfield = BITFIELD64_BIT(idx - VARYING_SLOT_PATCH0); |
| } |
| else { |
| assert(idx < VARYING_SLOT_MAX); |
| bitfield = BITFIELD64_BIT(idx); |
| } |
| |
| if (var->data.mode == ir_var_shader_in) { |
| if (is_patch_generic) |
| prog->info.patch_inputs_read |= bitfield; |
| else |
| prog->info.inputs_read |= bitfield; |
| |
| /* double inputs read is only for vertex inputs */ |
| if (stage == MESA_SHADER_VERTEX && |
| var->type->without_array()->is_dual_slot()) |
| prog->info.vs.double_inputs_read |= bitfield; |
| |
| if (stage == MESA_SHADER_FRAGMENT) { |
| prog->info.fs.uses_sample_qualifier |= var->data.sample; |
| } |
| } else if (var->data.mode == ir_var_system_value) { |
| prog->info.system_values_read |= bitfield; |
| } else { |
| assert(var->data.mode == ir_var_shader_out); |
| if (is_patch_generic) { |
| prog->info.patch_outputs_written |= bitfield; |
| } else if (!var->data.read_only) { |
| prog->info.outputs_written |= bitfield; |
| if (var->data.index > 0) |
| prog->SecondaryOutputsWritten |= bitfield; |
| } |
| |
| if (var->data.fb_fetch_output) |
| prog->info.outputs_read |= bitfield; |
| } |
| } |
| } |
| |
| /** |
| * Mark an entire variable as used. Caller must ensure that the variable |
| * represents a shader input or output. |
| */ |
| void |
| ir_set_program_inouts_visitor::mark_whole_variable(ir_variable *var) |
| { |
| const glsl_type *type = var->type; |
| bool is_vertex_input = false; |
| if (this->shader_stage == MESA_SHADER_GEOMETRY && |
| var->data.mode == ir_var_shader_in && type->is_array()) { |
| type = type->fields.array; |
| } |
| |
| if (this->shader_stage == MESA_SHADER_TESS_CTRL && |
| var->data.mode == ir_var_shader_in) { |
| assert(type->is_array()); |
| type = type->fields.array; |
| } |
| |
| if (this->shader_stage == MESA_SHADER_TESS_CTRL && |
| var->data.mode == ir_var_shader_out && !var->data.patch) { |
| assert(type->is_array()); |
| type = type->fields.array; |
| } |
| |
| if (this->shader_stage == MESA_SHADER_TESS_EVAL && |
| var->data.mode == ir_var_shader_in && !var->data.patch) { |
| assert(type->is_array()); |
| type = type->fields.array; |
| } |
| |
| if (this->shader_stage == MESA_SHADER_VERTEX && |
| var->data.mode == ir_var_shader_in) |
| is_vertex_input = true; |
| |
| mark(this->prog, var, 0, type->count_attribute_slots(is_vertex_input), |
| this->shader_stage); |
| } |
| |
| /* Default handler: Mark all the locations in the variable as used. */ |
| ir_visitor_status |
| ir_set_program_inouts_visitor::visit(ir_dereference_variable *ir) |
| { |
| if (!is_shader_inout(ir->var)) |
| return visit_continue; |
| |
| mark_whole_variable(ir->var); |
| |
| return visit_continue; |
| } |
| |
| /** |
| * Try to mark a portion of the given variable as used. Caller must ensure |
| * that the variable represents a shader input or output which can be indexed |
| * into in array fashion (an array or matrix). For the purpose of geometry |
| * shader inputs (which are always arrays*), this means that the array element |
| * must be something that can be indexed into in array fashion. |
| * |
| * *Except gl_PrimitiveIDIn, as noted below. |
| * |
| * For tessellation control shaders all inputs and non-patch outputs are |
| * arrays. For tessellation evaluation shaders non-patch inputs are arrays. |
| * |
| * If the index can't be interpreted as a constant, or some other problem |
| * occurs, then nothing will be marked and false will be returned. |
| */ |
| bool |
| ir_set_program_inouts_visitor::try_mark_partial_variable(ir_variable *var, |
| ir_rvalue *index) |
| { |
| const glsl_type *type = var->type; |
| |
| if (this->shader_stage == MESA_SHADER_GEOMETRY && |
| var->data.mode == ir_var_shader_in) { |
| /* The only geometry shader input that is not an array is |
| * gl_PrimitiveIDIn, and in that case, this code will never be reached, |
| * because gl_PrimitiveIDIn can't be indexed into in array fashion. |
| */ |
| assert(type->is_array()); |
| type = type->fields.array; |
| } |
| |
| if (this->shader_stage == MESA_SHADER_TESS_CTRL && |
| var->data.mode == ir_var_shader_in) { |
| assert(type->is_array()); |
| type = type->fields.array; |
| } |
| |
| if (this->shader_stage == MESA_SHADER_TESS_CTRL && |
| var->data.mode == ir_var_shader_out && !var->data.patch) { |
| assert(type->is_array()); |
| type = type->fields.array; |
| } |
| |
| if (this->shader_stage == MESA_SHADER_TESS_EVAL && |
| var->data.mode == ir_var_shader_in && !var->data.patch) { |
| assert(type->is_array()); |
| type = type->fields.array; |
| } |
| |
| /* TODO: implement proper arrays of arrays support |
| * for now let the caller mark whole variable as used. |
| */ |
| if (type->is_array() && type->fields.array->is_array()) |
| return false; |
| |
| /* The code below only handles: |
| * |
| * - Indexing into matrices |
| * - Indexing into arrays of (matrices, vectors, or scalars) |
| * |
| * All other possibilities are either prohibited by GLSL (vertex inputs and |
| * fragment outputs can't be structs) or should have been eliminated by |
| * lowering passes (do_vec_index_to_swizzle() gets rid of indexing into |
| * vectors, and lower_packed_varyings() gets rid of structs that occur in |
| * varyings). |
| * |
| * However, we don't use varying packing in all cases - tessellation |
| * shaders bypass it. This means we'll see varying structs and arrays |
| * of structs here. For now, we just give up so the caller marks the |
| * entire variable as used. |
| */ |
| if (!(type->is_matrix() || |
| (type->is_array() && |
| (type->fields.array->is_numeric() || |
| type->fields.array->is_boolean())))) { |
| |
| /* If we don't know how to handle this case, give up and let the |
| * caller mark the whole variable as used. |
| */ |
| return false; |
| } |
| |
| ir_constant *index_as_constant = index->as_constant(); |
| if (!index_as_constant) |
| return false; |
| |
| unsigned elem_width; |
| unsigned num_elems; |
| if (type->is_array()) { |
| num_elems = type->length; |
| if (type->fields.array->is_matrix()) |
| elem_width = type->fields.array->matrix_columns; |
| else |
| elem_width = 1; |
| } else { |
| num_elems = type->matrix_columns; |
| elem_width = 1; |
| } |
| |
| if (index_as_constant->value.u[0] >= num_elems) { |
| /* Constant index outside the bounds of the matrix/array. This could |
| * arise as a result of constant folding of a legal GLSL program. |
| * |
| * Even though the spec says that indexing outside the bounds of a |
| * matrix/array results in undefined behaviour, we don't want to pass |
| * out-of-range values to mark() (since this could result in slots that |
| * don't exist being marked as used), so just let the caller mark the |
| * whole variable as used. |
| */ |
| return false; |
| } |
| |
| /* double element width for double types that takes two slots */ |
| if (this->shader_stage != MESA_SHADER_VERTEX || |
| var->data.mode != ir_var_shader_in) { |
| if (type->without_array()->is_dual_slot()) |
| elem_width *= 2; |
| } |
| |
| mark(this->prog, var, index_as_constant->value.u[0] * elem_width, |
| elem_width, this->shader_stage); |
| return true; |
| } |
| |
| static bool |
| is_multiple_vertices(gl_shader_stage stage, ir_variable *var) |
| { |
| if (var->data.patch) |
| return false; |
| |
| if (var->data.mode == ir_var_shader_in) |
| return stage == MESA_SHADER_GEOMETRY || |
| stage == MESA_SHADER_TESS_CTRL || |
| stage == MESA_SHADER_TESS_EVAL; |
| if (var->data.mode == ir_var_shader_out) |
| return stage == MESA_SHADER_TESS_CTRL; |
| |
| return false; |
| } |
| |
| ir_visitor_status |
| ir_set_program_inouts_visitor::visit_enter(ir_dereference_array *ir) |
| { |
| /* Note: for geometry shader inputs, lower_named_interface_blocks may |
| * create 2D arrays, so we need to be able to handle those. 2D arrays |
| * shouldn't be able to crop up for any other reason. |
| */ |
| if (ir_dereference_array * const inner_array = |
| ir->array->as_dereference_array()) { |
| /* ir => foo[i][j] |
| * inner_array => foo[i] |
| */ |
| if (ir_dereference_variable * const deref_var = |
| inner_array->array->as_dereference_variable()) { |
| if (is_multiple_vertices(this->shader_stage, deref_var->var)) { |
| /* foo is a geometry or tessellation shader input, so i is |
| * the vertex, and j the part of the input we're accessing. |
| */ |
| if (try_mark_partial_variable(deref_var->var, ir->array_index)) |
| { |
| /* We've now taken care of foo and j, but i might contain a |
| * subexpression that accesses shader inputs. So manually |
| * visit i and then continue with the parent. |
| */ |
| inner_array->array_index->accept(this); |
| return visit_continue_with_parent; |
| } |
| } |
| } |
| } else if (ir_dereference_variable * const deref_var = |
| ir->array->as_dereference_variable()) { |
| /* ir => foo[i], where foo is a variable. */ |
| if (is_multiple_vertices(this->shader_stage, deref_var->var)) { |
| /* foo is a geometry or tessellation shader input, so i is |
| * the vertex, and we're accessing the entire input. |
| */ |
| mark_whole_variable(deref_var->var); |
| /* We've now taken care of foo, but i might contain a subexpression |
| * that accesses shader inputs. So manually visit i and then |
| * continue with the parent. |
| */ |
| ir->array_index->accept(this); |
| return visit_continue_with_parent; |
| } else if (is_shader_inout(deref_var->var)) { |
| /* foo is a shader input/output, but not a geometry shader input, |
| * so i is the part of the input we're accessing. |
| */ |
| if (try_mark_partial_variable(deref_var->var, ir->array_index)) |
| return visit_continue_with_parent; |
| } |
| } |
| |
| /* The expression is something we don't recognize. Just visit its |
| * subexpressions. |
| */ |
| return visit_continue; |
| } |
| |
| ir_visitor_status |
| ir_set_program_inouts_visitor::visit_enter(ir_function_signature *ir) |
| { |
| /* We don't want to descend into the function parameters and |
| * consider them as shader inputs or outputs. |
| */ |
| visit_list_elements(this, &ir->body); |
| return visit_continue_with_parent; |
| } |
| |
| ir_visitor_status |
| ir_set_program_inouts_visitor::visit_enter(ir_discard *) |
| { |
| /* discards are only allowed in fragment shaders. */ |
| assert(this->shader_stage == MESA_SHADER_FRAGMENT); |
| |
| prog->info.fs.uses_discard = true; |
| |
| return visit_continue; |
| } |
| |
| ir_visitor_status |
| ir_set_program_inouts_visitor::visit_enter(ir_texture *ir) |
| { |
| if (ir->op == ir_tg4) |
| prog->info.uses_texture_gather = true; |
| return visit_continue; |
| } |
| |
| void |
| do_set_program_inouts(exec_list *instructions, struct gl_program *prog, |
| gl_shader_stage shader_stage) |
| { |
| ir_set_program_inouts_visitor v(prog, shader_stage); |
| |
| prog->info.inputs_read = 0; |
| prog->info.outputs_written = 0; |
| prog->SecondaryOutputsWritten = 0; |
| prog->info.outputs_read = 0; |
| prog->info.patch_inputs_read = 0; |
| prog->info.patch_outputs_written = 0; |
| prog->info.system_values_read = 0; |
| if (shader_stage == MESA_SHADER_FRAGMENT) { |
| prog->info.fs.uses_sample_qualifier = false; |
| prog->info.fs.uses_discard = false; |
| } |
| visit_list_elements(&v, instructions); |
| } |
