1 /* -*- c++ -*- */ 2 /* 3 * Copyright © 2010 Intel Corporation 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 */ 24 25 #ifndef GLSL_LINKER_H 26 #define GLSL_LINKER_H 27 28 extern bool 29 link_function_calls(gl_shader_program *prog, gl_linked_shader *main, 30 gl_shader **shader_list, unsigned num_shaders); 31 32 extern void 33 link_invalidate_variable_locations(exec_list *ir); 34 35 extern void 36 link_assign_uniform_locations(struct gl_shader_program *prog, 37 struct gl_context *ctx); 38 39 extern void 40 link_set_uniform_initializers(struct gl_shader_program *prog, 41 unsigned int boolean_true); 42 43 extern int 44 link_cross_validate_uniform_block(void *mem_ctx, 45 struct gl_uniform_block **linked_blocks, 46 unsigned int *num_linked_blocks, 47 struct gl_uniform_block *new_block); 48 49 extern void 50 link_uniform_blocks(void *mem_ctx, 51 struct gl_context *ctx, 52 struct gl_shader_program *prog, 53 struct gl_linked_shader *shader, 54 struct gl_uniform_block **ubo_blocks, 55 unsigned *num_ubo_blocks, 56 struct gl_uniform_block **ssbo_blocks, 57 unsigned *num_ssbo_blocks); 58 59 bool 60 validate_intrastage_arrays(struct gl_shader_program *prog, 61 ir_variable *const var, 62 ir_variable *const existing); 63 64 void 65 validate_intrastage_interface_blocks(struct gl_shader_program *prog, 66 const gl_shader **shader_list, 67 unsigned num_shaders); 68 69 void 70 validate_interstage_inout_blocks(struct gl_shader_program *prog, 71 const gl_linked_shader *producer, 72 const gl_linked_shader *consumer); 73 74 void 75 validate_interstage_uniform_blocks(struct gl_shader_program *prog, 76 gl_linked_shader **stages); 77 78 extern void 79 link_assign_atomic_counter_resources(struct gl_context *ctx, 80 struct gl_shader_program *prog); 81 82 extern void 83 link_check_atomic_counter_resources(struct gl_context *ctx, 84 struct gl_shader_program *prog); 85 86 87 extern struct gl_linked_shader * 88 link_intrastage_shaders(void *mem_ctx, 89 struct gl_context *ctx, 90 struct gl_shader_program *prog, 91 struct gl_shader **shader_list, 92 unsigned num_shaders, 93 bool allow_missing_main); 94 95 extern unsigned 96 link_calculate_matrix_stride(const glsl_type *matrix, bool row_major, 97 enum glsl_interface_packing packing); 98 99 /** 100 * Class for processing all of the leaf fields of a variable that corresponds 101 * to a program resource. 102 * 103 * The leaf fields are all the parts of the variable that the application 104 * could query using \c glGetProgramResourceIndex (or that could be returned 105 * by \c glGetProgramResourceName). 106 * 107 * Classes my derive from this class to implement specific functionality. 108 * This class only provides the mechanism to iterate over the leaves. Derived 109 * classes must implement \c ::visit_field and may override \c ::process. 110 */ 111 class program_resource_visitor { 112 public: 113 /** 114 * Begin processing a variable 115 * 116 * Classes that overload this function should call \c ::process from the 117 * base class to start the recursive processing of the variable. 118 * 119 * \param var The variable that is to be processed 120 * 121 * Calls \c ::visit_field for each leaf of the variable. 122 * 123 * \warning 124 * When processing a uniform block, this entry should only be used in cases 125 * where the row / column ordering of matrices in the block does not 126 * matter. For example, enumerating the names of members of the block, but 127 * not for determining the offsets of members. 128 */ 129 void process(ir_variable *var, bool use_std430_as_default); 130 131 /** 132 * Begin processing a variable of a structured type. 133 * 134 * This flavor of \c process should be used to handle structured types 135 * (i.e., structures, interfaces, or arrays there of) that need special 136 * name handling. A common usage is to handle cases where the block name 137 * (instead of the instance name) is used for an interface block. 138 * 139 * \param type Type that is to be processed, associated with \c name 140 * \param name Base name of the structured variable being processed 141 * 142 * \note 143 * \c type must be \c GLSL_TYPE_RECORD, \c GLSL_TYPE_INTERFACE, or an array 144 * there of. 145 */ 146 void process(const glsl_type *type, const char *name, 147 bool use_std430_as_default); 148 149 protected: 150 /** 151 * Method invoked for each leaf of the variable 152 * 153 * \param type Type of the field. 154 * \param name Fully qualified name of the field. 155 * \param row_major For a matrix type, is it stored row-major. 156 * \param record_type Type of the record containing the field. 157 * \param last_field Set if \c name is the last field of the structure 158 * containing it. This will always be false for items 159 * not contained in a structure or interface block. 160 */ 161 virtual void visit_field(const glsl_type *type, const char *name, 162 bool row_major, const glsl_type *record_type, 163 const enum glsl_interface_packing packing, 164 bool last_field) = 0; 165 166 virtual void enter_record(const glsl_type *type, const char *name, 167 bool row_major, const enum glsl_interface_packing packing); 168 169 virtual void leave_record(const glsl_type *type, const char *name, 170 bool row_major, const enum glsl_interface_packing packing); 171 172 virtual void set_buffer_offset(unsigned offset); 173 174 virtual void set_record_array_count(unsigned record_array_count); 175 176 private: 177 /** 178 * \param name_length Length of the current name \b not including the 179 * terminating \c NUL character. 180 * \param last_field Set if \c name is the last field of the structure 181 * containing it. This will always be false for items 182 * not contained in a structure or interface block. 183 */ 184 void recursion(const glsl_type *t, char **name, size_t name_length, 185 bool row_major, const glsl_type *record_type, 186 const enum glsl_interface_packing packing, 187 bool last_field, unsigned record_array_count, 188 const glsl_struct_field *named_ifc_member); 189 }; 190 191 void 192 linker_error(gl_shader_program *prog, const char *fmt, ...); 193 194 void 195 linker_warning(gl_shader_program *prog, const char *fmt, ...); 196 197 /** 198 * Sometimes there are empty slots left over in UniformRemapTable after we 199 * allocate slots to explicit locations. This struct represents a single 200 * continouous block of empty slots in UniformRemapTable. 201 */ 202 struct empty_uniform_block { 203 struct exec_node link; 204 /* The start location of the block */ 205 unsigned start; 206 /* The number of slots in the block */ 207 unsigned slots; 208 }; 209 210 #endif /* GLSL_LINKER_H */ 211