linker.h revision 01e04c3f 
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#include "linker_util.h"
29
30struct gl_shader_program;
31struct gl_shader;
32struct gl_linked_shader;
33
34extern bool
35link_function_calls(gl_shader_program *prog, gl_linked_shader *main,
36                    gl_shader **shader_list, unsigned num_shaders);
37
38extern void
39link_invalidate_variable_locations(exec_list *ir);
40
41extern void
42link_assign_uniform_locations(struct gl_shader_program *prog,
43                              struct gl_context *ctx);
44
45extern void
46link_set_uniform_initializers(struct gl_shader_program *prog,
47                              unsigned int boolean_true);
48
49extern int
50link_cross_validate_uniform_block(void *mem_ctx,
51                                  struct gl_uniform_block **linked_blocks,
52                                  unsigned int *num_linked_blocks,
53                                  struct gl_uniform_block *new_block);
54
55extern void
56link_uniform_blocks(void *mem_ctx,
57                    struct gl_context *ctx,
58                    struct gl_shader_program *prog,
59                    struct gl_linked_shader *shader,
60                    struct gl_uniform_block **ubo_blocks,
61                    unsigned *num_ubo_blocks,
62                    struct gl_uniform_block **ssbo_blocks,
63                    unsigned *num_ssbo_blocks);
64
65bool
66validate_intrastage_arrays(struct gl_shader_program *prog,
67                           ir_variable *const var,
68                           ir_variable *const existing);
69
70void
71validate_intrastage_interface_blocks(struct gl_shader_program *prog,
72                                     const gl_shader **shader_list,
73                                     unsigned num_shaders);
74
75void
76validate_interstage_inout_blocks(struct gl_shader_program *prog,
77                                 const gl_linked_shader *producer,
78                                 const gl_linked_shader *consumer);
79
80void
81validate_interstage_uniform_blocks(struct gl_shader_program *prog,
82                                   gl_linked_shader **stages);
83
84extern void
85link_assign_atomic_counter_resources(struct gl_context *ctx,
86                                     struct gl_shader_program *prog);
87
88extern void
89link_check_atomic_counter_resources(struct gl_context *ctx,
90                                    struct gl_shader_program *prog);
91
92
93extern struct gl_linked_shader *
94link_intrastage_shaders(void *mem_ctx,
95                        struct gl_context *ctx,
96                        struct gl_shader_program *prog,
97                        struct gl_shader **shader_list,
98                        unsigned num_shaders,
99                        bool allow_missing_main);
100
101extern unsigned
102link_calculate_matrix_stride(const glsl_type *matrix, bool row_major,
103                             enum glsl_interface_packing packing);
104
105/**
106 * Class for processing all of the leaf fields of a variable that corresponds
107 * to a program resource.
108 *
109 * The leaf fields are all the parts of the variable that the application
110 * could query using \c glGetProgramResourceIndex (or that could be returned
111 * by \c glGetProgramResourceName).
112 *
113 * Classes my derive from this class to implement specific functionality.
114 * This class only provides the mechanism to iterate over the leaves.  Derived
115 * classes must implement \c ::visit_field and may override \c ::process.
116 */
117class program_resource_visitor {
118public:
119   /**
120    * Begin processing a variable
121    *
122    * Classes that overload this function should call \c ::process from the
123    * base class to start the recursive processing of the variable.
124    *
125    * \param var  The variable that is to be processed
126    *
127    * Calls \c ::visit_field for each leaf of the variable.
128    *
129    * \warning
130    * When processing a uniform block, this entry should only be used in cases
131    * where the row / column ordering of matrices in the block does not
132    * matter.  For example, enumerating the names of members of the block, but
133    * not for determining the offsets of members.
134    */
135   void process(ir_variable *var, bool use_std430_as_default);
136
137   /**
138    * Begin processing a variable of a structured type.
139    *
140    * This flavor of \c process should be used to handle structured types
141    * (i.e., structures, interfaces, or arrays there of) that need special
142    * name handling.  A common usage is to handle cases where the block name
143    * (instead of the instance name) is used for an interface block.
144    *
145    * \param type  Type that is to be processed, associated with \c name
146    * \param name  Base name of the structured variable being processed
147    *
148    * \note
149    * \c type must be \c GLSL_TYPE_RECORD, \c GLSL_TYPE_INTERFACE, or an array
150    * there of.
151    */
152   void process(const glsl_type *type, const char *name,
153                bool use_std430_as_default);
154
155protected:
156   /**
157    * Method invoked for each leaf of the variable
158    *
159    * \param type  Type of the field.
160    * \param name  Fully qualified name of the field.
161    * \param row_major  For a matrix type, is it stored row-major.
162    * \param record_type  Type of the record containing the field.
163    * \param last_field   Set if \c name is the last field of the structure
164    *                     containing it.  This will always be false for items
165    *                     not contained in a structure or interface block.
166    */
167   virtual void visit_field(const glsl_type *type, const char *name,
168                            bool row_major, const glsl_type *record_type,
169                            const enum glsl_interface_packing packing,
170                            bool last_field) = 0;
171
172   virtual void enter_record(const glsl_type *type, const char *name,
173                             bool row_major, const enum glsl_interface_packing packing);
174
175   virtual void leave_record(const glsl_type *type, const char *name,
176                             bool row_major, const enum glsl_interface_packing packing);
177
178   virtual void set_buffer_offset(unsigned offset);
179
180   virtual void set_record_array_count(unsigned record_array_count);
181
182private:
183   /**
184    * \param name_length  Length of the current name \b not including the
185    *                     terminating \c NUL character.
186    * \param last_field   Set if \c name is the last field of the structure
187    *                     containing it.  This will always be false for items
188    *                     not contained in a structure or interface block.
189    */
190   void recursion(const glsl_type *t, char **name, size_t name_length,
191                  bool row_major, const glsl_type *record_type,
192                  const enum glsl_interface_packing packing,
193                  bool last_field, unsigned record_array_count,
194                  const glsl_struct_field *named_ifc_member);
195};
196
197#endif /* GLSL_LINKER_H */
198