• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright © 2010 Intel Corporation
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  */
23 
24 #include "ir.h"
25 #include "ir_builder.h"
26 #include "linker.h"
27 #include "glsl_parser_extras.h"
28 #include "glsl_symbol_table.h"
29 #include "main/core.h"
30 #include "main/uniforms.h"
31 #include "program/prog_statevars.h"
32 #include "program/prog_instruction.h"
33 #include "builtin_functions.h"
34 
35 using namespace ir_builder;
36 
37 static const struct gl_builtin_uniform_element gl_NumSamples_elements[] = {
38    {NULL, {STATE_NUM_SAMPLES, 0, 0}, SWIZZLE_XXXX}
39 };
40 
41 static const struct gl_builtin_uniform_element gl_DepthRange_elements[] = {
42    {"near", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_XXXX},
43    {"far", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_YYYY},
44    {"diff", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_ZZZZ},
45 };
46 
47 static const struct gl_builtin_uniform_element gl_ClipPlane_elements[] = {
48    {NULL, {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW}
49 };
50 
51 static const struct gl_builtin_uniform_element gl_Point_elements[] = {
52    {"size", {STATE_POINT_SIZE}, SWIZZLE_XXXX},
53    {"sizeMin", {STATE_POINT_SIZE}, SWIZZLE_YYYY},
54    {"sizeMax", {STATE_POINT_SIZE}, SWIZZLE_ZZZZ},
55    {"fadeThresholdSize", {STATE_POINT_SIZE}, SWIZZLE_WWWW},
56    {"distanceConstantAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_XXXX},
57    {"distanceLinearAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_YYYY},
58    {"distanceQuadraticAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_ZZZZ},
59 };
60 
61 static const struct gl_builtin_uniform_element gl_FrontMaterial_elements[] = {
62    {"emission", {STATE_MATERIAL, 0, STATE_EMISSION}, SWIZZLE_XYZW},
63    {"ambient", {STATE_MATERIAL, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
64    {"diffuse", {STATE_MATERIAL, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
65    {"specular", {STATE_MATERIAL, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
66    {"shininess", {STATE_MATERIAL, 0, STATE_SHININESS}, SWIZZLE_XXXX},
67 };
68 
69 static const struct gl_builtin_uniform_element gl_BackMaterial_elements[] = {
70    {"emission", {STATE_MATERIAL, 1, STATE_EMISSION}, SWIZZLE_XYZW},
71    {"ambient", {STATE_MATERIAL, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
72    {"diffuse", {STATE_MATERIAL, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
73    {"specular", {STATE_MATERIAL, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
74    {"shininess", {STATE_MATERIAL, 1, STATE_SHININESS}, SWIZZLE_XXXX},
75 };
76 
77 static const struct gl_builtin_uniform_element gl_LightSource_elements[] = {
78    {"ambient", {STATE_LIGHT, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
79    {"diffuse", {STATE_LIGHT, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
80    {"specular", {STATE_LIGHT, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
81    {"position", {STATE_LIGHT, 0, STATE_POSITION}, SWIZZLE_XYZW},
82    {"halfVector", {STATE_LIGHT, 0, STATE_HALF_VECTOR}, SWIZZLE_XYZW},
83    {"spotDirection", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION},
84     MAKE_SWIZZLE4(SWIZZLE_X,
85 		  SWIZZLE_Y,
86 		  SWIZZLE_Z,
87 		  SWIZZLE_Z)},
88    {"spotExponent", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_WWWW},
89    {"spotCutoff", {STATE_LIGHT, 0, STATE_SPOT_CUTOFF}, SWIZZLE_XXXX},
90    {"spotCosCutoff", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_WWWW},
91    {"constantAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_XXXX},
92    {"linearAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_YYYY},
93    {"quadraticAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_ZZZZ},
94 };
95 
96 static const struct gl_builtin_uniform_element gl_LightModel_elements[] = {
97    {"ambient", {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW},
98 };
99 
100 static const struct gl_builtin_uniform_element gl_FrontLightModelProduct_elements[] = {
101    {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW},
102 };
103 
104 static const struct gl_builtin_uniform_element gl_BackLightModelProduct_elements[] = {
105    {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW},
106 };
107 
108 static const struct gl_builtin_uniform_element gl_FrontLightProduct_elements[] = {
109    {"ambient", {STATE_LIGHTPROD, 0, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
110    {"diffuse", {STATE_LIGHTPROD, 0, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
111    {"specular", {STATE_LIGHTPROD, 0, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
112 };
113 
114 static const struct gl_builtin_uniform_element gl_BackLightProduct_elements[] = {
115    {"ambient", {STATE_LIGHTPROD, 0, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
116    {"diffuse", {STATE_LIGHTPROD, 0, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
117    {"specular", {STATE_LIGHTPROD, 0, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
118 };
119 
120 static const struct gl_builtin_uniform_element gl_TextureEnvColor_elements[] = {
121    {NULL, {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW},
122 };
123 
124 static const struct gl_builtin_uniform_element gl_EyePlaneS_elements[] = {
125    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW},
126 };
127 
128 static const struct gl_builtin_uniform_element gl_EyePlaneT_elements[] = {
129    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW},
130 };
131 
132 static const struct gl_builtin_uniform_element gl_EyePlaneR_elements[] = {
133    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW},
134 };
135 
136 static const struct gl_builtin_uniform_element gl_EyePlaneQ_elements[] = {
137    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW},
138 };
139 
140 static const struct gl_builtin_uniform_element gl_ObjectPlaneS_elements[] = {
141    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW},
142 };
143 
144 static const struct gl_builtin_uniform_element gl_ObjectPlaneT_elements[] = {
145    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW},
146 };
147 
148 static const struct gl_builtin_uniform_element gl_ObjectPlaneR_elements[] = {
149    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW},
150 };
151 
152 static const struct gl_builtin_uniform_element gl_ObjectPlaneQ_elements[] = {
153    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW},
154 };
155 
156 static const struct gl_builtin_uniform_element gl_Fog_elements[] = {
157    {"color", {STATE_FOG_COLOR}, SWIZZLE_XYZW},
158    {"density", {STATE_FOG_PARAMS}, SWIZZLE_XXXX},
159    {"start", {STATE_FOG_PARAMS}, SWIZZLE_YYYY},
160    {"end", {STATE_FOG_PARAMS}, SWIZZLE_ZZZZ},
161    {"scale", {STATE_FOG_PARAMS}, SWIZZLE_WWWW},
162 };
163 
164 static const struct gl_builtin_uniform_element gl_NormalScale_elements[] = {
165    {NULL, {STATE_NORMAL_SCALE}, SWIZZLE_XXXX},
166 };
167 
168 static const struct gl_builtin_uniform_element gl_FogParamsOptimizedMESA_elements[] = {
169    {NULL, {STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED}, SWIZZLE_XYZW},
170 };
171 
172 static const struct gl_builtin_uniform_element gl_CurrentAttribVertMESA_elements[] = {
173    {NULL, {STATE_INTERNAL, STATE_CURRENT_ATTRIB, 0}, SWIZZLE_XYZW},
174 };
175 
176 static const struct gl_builtin_uniform_element gl_CurrentAttribFragMESA_elements[] = {
177    {NULL, {STATE_INTERNAL, STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED, 0}, SWIZZLE_XYZW},
178 };
179 
180 #define MATRIX(name, statevar, modifier)				\
181    static const struct gl_builtin_uniform_element name ## _elements[] = { \
182       { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW },		\
183       { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW },		\
184       { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW },		\
185       { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW },		\
186    }
187 
188 MATRIX(gl_ModelViewMatrix,
189        STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE);
190 MATRIX(gl_ModelViewMatrixInverse,
191        STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS);
192 MATRIX(gl_ModelViewMatrixTranspose,
193        STATE_MODELVIEW_MATRIX, 0);
194 MATRIX(gl_ModelViewMatrixInverseTranspose,
195        STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE);
196 
197 MATRIX(gl_ProjectionMatrix,
198        STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE);
199 MATRIX(gl_ProjectionMatrixInverse,
200        STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS);
201 MATRIX(gl_ProjectionMatrixTranspose,
202        STATE_PROJECTION_MATRIX, 0);
203 MATRIX(gl_ProjectionMatrixInverseTranspose,
204        STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE);
205 
206 MATRIX(gl_ModelViewProjectionMatrix,
207        STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE);
208 MATRIX(gl_ModelViewProjectionMatrixInverse,
209        STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS);
210 MATRIX(gl_ModelViewProjectionMatrixTranspose,
211        STATE_MVP_MATRIX, 0);
212 MATRIX(gl_ModelViewProjectionMatrixInverseTranspose,
213        STATE_MVP_MATRIX, STATE_MATRIX_INVERSE);
214 
215 MATRIX(gl_TextureMatrix,
216        STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE);
217 MATRIX(gl_TextureMatrixInverse,
218        STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS);
219 MATRIX(gl_TextureMatrixTranspose,
220        STATE_TEXTURE_MATRIX, 0);
221 MATRIX(gl_TextureMatrixInverseTranspose,
222        STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE);
223 
224 static const struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = {
225    { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE},
226      MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
227    { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE},
228      MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
229    { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE},
230      MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
231 };
232 
233 #undef MATRIX
234 
235 #define STATEVAR(name) {#name, name ## _elements, ARRAY_SIZE(name ## _elements)}
236 
237 static const struct gl_builtin_uniform_desc _mesa_builtin_uniform_desc[] = {
238    STATEVAR(gl_NumSamples),
239    STATEVAR(gl_DepthRange),
240    STATEVAR(gl_ClipPlane),
241    STATEVAR(gl_Point),
242    STATEVAR(gl_FrontMaterial),
243    STATEVAR(gl_BackMaterial),
244    STATEVAR(gl_LightSource),
245    STATEVAR(gl_LightModel),
246    STATEVAR(gl_FrontLightModelProduct),
247    STATEVAR(gl_BackLightModelProduct),
248    STATEVAR(gl_FrontLightProduct),
249    STATEVAR(gl_BackLightProduct),
250    STATEVAR(gl_TextureEnvColor),
251    STATEVAR(gl_EyePlaneS),
252    STATEVAR(gl_EyePlaneT),
253    STATEVAR(gl_EyePlaneR),
254    STATEVAR(gl_EyePlaneQ),
255    STATEVAR(gl_ObjectPlaneS),
256    STATEVAR(gl_ObjectPlaneT),
257    STATEVAR(gl_ObjectPlaneR),
258    STATEVAR(gl_ObjectPlaneQ),
259    STATEVAR(gl_Fog),
260 
261    STATEVAR(gl_ModelViewMatrix),
262    STATEVAR(gl_ModelViewMatrixInverse),
263    STATEVAR(gl_ModelViewMatrixTranspose),
264    STATEVAR(gl_ModelViewMatrixInverseTranspose),
265 
266    STATEVAR(gl_ProjectionMatrix),
267    STATEVAR(gl_ProjectionMatrixInverse),
268    STATEVAR(gl_ProjectionMatrixTranspose),
269    STATEVAR(gl_ProjectionMatrixInverseTranspose),
270 
271    STATEVAR(gl_ModelViewProjectionMatrix),
272    STATEVAR(gl_ModelViewProjectionMatrixInverse),
273    STATEVAR(gl_ModelViewProjectionMatrixTranspose),
274    STATEVAR(gl_ModelViewProjectionMatrixInverseTranspose),
275 
276    STATEVAR(gl_TextureMatrix),
277    STATEVAR(gl_TextureMatrixInverse),
278    STATEVAR(gl_TextureMatrixTranspose),
279    STATEVAR(gl_TextureMatrixInverseTranspose),
280 
281    STATEVAR(gl_NormalMatrix),
282    STATEVAR(gl_NormalScale),
283 
284    STATEVAR(gl_FogParamsOptimizedMESA),
285    STATEVAR(gl_CurrentAttribVertMESA),
286    STATEVAR(gl_CurrentAttribFragMESA),
287 
288    {NULL, NULL, 0}
289 };
290 
291 
292 namespace {
293 
294 /**
295  * Data structure that accumulates fields for the gl_PerVertex interface
296  * block.
297  */
298 class per_vertex_accumulator
299 {
300 public:
301    per_vertex_accumulator();
302    void add_field(int slot, const glsl_type *type, const char *name);
303    const glsl_type *construct_interface_instance() const;
304 
305 private:
306    glsl_struct_field fields[11];
307    unsigned num_fields;
308 };
309 
310 
per_vertex_accumulator()311 per_vertex_accumulator::per_vertex_accumulator()
312    : fields(),
313      num_fields(0)
314 {
315 }
316 
317 
318 void
add_field(int slot,const glsl_type * type,const char * name)319 per_vertex_accumulator::add_field(int slot, const glsl_type *type,
320                                   const char *name)
321 {
322    assert(this->num_fields < ARRAY_SIZE(this->fields));
323    this->fields[this->num_fields].type = type;
324    this->fields[this->num_fields].name = name;
325    this->fields[this->num_fields].matrix_layout = GLSL_MATRIX_LAYOUT_INHERITED;
326    this->fields[this->num_fields].location = slot;
327    this->fields[this->num_fields].offset = -1;
328    this->fields[this->num_fields].interpolation = INTERP_MODE_NONE;
329    this->fields[this->num_fields].centroid = 0;
330    this->fields[this->num_fields].sample = 0;
331    this->fields[this->num_fields].patch = 0;
332    this->fields[this->num_fields].precision = GLSL_PRECISION_NONE;
333    this->fields[this->num_fields].memory_read_only = 0;
334    this->fields[this->num_fields].memory_write_only = 0;
335    this->fields[this->num_fields].memory_coherent = 0;
336    this->fields[this->num_fields].memory_volatile = 0;
337    this->fields[this->num_fields].memory_restrict = 0;
338    this->fields[this->num_fields].image_format = 0;
339    this->fields[this->num_fields].explicit_xfb_buffer = 0;
340    this->fields[this->num_fields].xfb_buffer = -1;
341    this->fields[this->num_fields].xfb_stride = -1;
342    this->num_fields++;
343 }
344 
345 
346 const glsl_type *
construct_interface_instance() const347 per_vertex_accumulator::construct_interface_instance() const
348 {
349    return glsl_type::get_interface_instance(this->fields, this->num_fields,
350                                             GLSL_INTERFACE_PACKING_STD140,
351                                             false,
352                                             "gl_PerVertex");
353 }
354 
355 
356 class builtin_variable_generator
357 {
358 public:
359    builtin_variable_generator(exec_list *instructions,
360                               struct _mesa_glsl_parse_state *state);
361    void generate_constants();
362    void generate_uniforms();
363    void generate_special_vars();
364    void generate_vs_special_vars();
365    void generate_tcs_special_vars();
366    void generate_tes_special_vars();
367    void generate_gs_special_vars();
368    void generate_fs_special_vars();
369    void generate_cs_special_vars();
370    void generate_varyings();
371 
372 private:
array(const glsl_type * base,unsigned elements)373    const glsl_type *array(const glsl_type *base, unsigned elements)
374    {
375       return glsl_type::get_array_instance(base, elements);
376    }
377 
type(const char * name)378    const glsl_type *type(const char *name)
379    {
380       return symtab->get_type(name);
381    }
382 
add_input(int slot,const glsl_type * type,const char * name)383    ir_variable *add_input(int slot, const glsl_type *type, const char *name)
384    {
385       return add_variable(name, type, ir_var_shader_in, slot);
386    }
387 
add_output(int slot,const glsl_type * type,const char * name)388    ir_variable *add_output(int slot, const glsl_type *type, const char *name)
389    {
390       return add_variable(name, type, ir_var_shader_out, slot);
391    }
392 
add_index_output(int slot,int index,const glsl_type * type,const char * name)393    ir_variable *add_index_output(int slot, int index, const glsl_type *type, const char *name)
394    {
395       return add_index_variable(name, type, ir_var_shader_out, slot, index);
396    }
397 
add_system_value(int slot,const glsl_type * type,const char * name)398    ir_variable *add_system_value(int slot, const glsl_type *type,
399                                  const char *name)
400    {
401       return add_variable(name, type, ir_var_system_value, slot);
402    }
403 
404    ir_variable *add_variable(const char *name, const glsl_type *type,
405                              enum ir_variable_mode mode, int slot);
406    ir_variable *add_index_variable(const char *name, const glsl_type *type,
407                              enum ir_variable_mode mode, int slot, int index);
408    ir_variable *add_uniform(const glsl_type *type, const char *name);
409    ir_variable *add_const(const char *name, int value);
410    ir_variable *add_const_ivec3(const char *name, int x, int y, int z);
411    void add_varying(int slot, const glsl_type *type, const char *name);
412 
413    exec_list * const instructions;
414    struct _mesa_glsl_parse_state * const state;
415    glsl_symbol_table * const symtab;
416 
417    /**
418     * True if compatibility-profile-only variables should be included.  (In
419     * desktop GL, these are always included when the GLSL version is 1.30 and
420     * or below).
421     */
422    const bool compatibility;
423 
424    const glsl_type * const bool_t;
425    const glsl_type * const int_t;
426    const glsl_type * const uint_t;
427    const glsl_type * const uint64_t;
428    const glsl_type * const float_t;
429    const glsl_type * const vec2_t;
430    const glsl_type * const vec3_t;
431    const glsl_type * const vec4_t;
432    const glsl_type * const uvec3_t;
433    const glsl_type * const mat3_t;
434    const glsl_type * const mat4_t;
435 
436    per_vertex_accumulator per_vertex_in;
437    per_vertex_accumulator per_vertex_out;
438 };
439 
440 
builtin_variable_generator(exec_list * instructions,struct _mesa_glsl_parse_state * state)441 builtin_variable_generator::builtin_variable_generator(
442    exec_list *instructions, struct _mesa_glsl_parse_state *state)
443    : instructions(instructions), state(state), symtab(state->symbols),
444      compatibility(state->compat_shader || !state->is_version(140, 100)),
445      bool_t(glsl_type::bool_type), int_t(glsl_type::int_type),
446      uint_t(glsl_type::uint_type),
447      uint64_t(glsl_type::uint64_t_type),
448      float_t(glsl_type::float_type), vec2_t(glsl_type::vec2_type),
449      vec3_t(glsl_type::vec3_type), vec4_t(glsl_type::vec4_type),
450      uvec3_t(glsl_type::uvec3_type),
451      mat3_t(glsl_type::mat3_type), mat4_t(glsl_type::mat4_type)
452 {
453 }
454 
455 ir_variable *
add_index_variable(const char * name,const glsl_type * type,enum ir_variable_mode mode,int slot,int index)456 builtin_variable_generator::add_index_variable(const char *name,
457                                          const glsl_type *type,
458                                          enum ir_variable_mode mode, int slot, int index)
459 {
460    ir_variable *var = new(symtab) ir_variable(type, name, mode);
461    var->data.how_declared = ir_var_declared_implicitly;
462 
463    switch (var->data.mode) {
464    case ir_var_auto:
465    case ir_var_shader_in:
466    case ir_var_uniform:
467    case ir_var_system_value:
468       var->data.read_only = true;
469       break;
470    case ir_var_shader_out:
471    case ir_var_shader_storage:
472       break;
473    default:
474       /* The only variables that are added using this function should be
475        * uniforms, shader storage, shader inputs, and shader outputs, constants
476        * (which use ir_var_auto), and system values.
477        */
478       assert(0);
479       break;
480    }
481 
482    var->data.location = slot;
483    var->data.explicit_location = (slot >= 0);
484    var->data.explicit_index = 1;
485    var->data.index = index;
486 
487    /* Once the variable is created an initialized, add it to the symbol table
488     * and add the declaration to the IR stream.
489     */
490    instructions->push_tail(var);
491 
492    symtab->add_variable(var);
493    return var;
494 }
495 
496 ir_variable *
add_variable(const char * name,const glsl_type * type,enum ir_variable_mode mode,int slot)497 builtin_variable_generator::add_variable(const char *name,
498                                          const glsl_type *type,
499                                          enum ir_variable_mode mode, int slot)
500 {
501    ir_variable *var = new(symtab) ir_variable(type, name, mode);
502    var->data.how_declared = ir_var_declared_implicitly;
503 
504    switch (var->data.mode) {
505    case ir_var_auto:
506    case ir_var_shader_in:
507    case ir_var_uniform:
508    case ir_var_system_value:
509       var->data.read_only = true;
510       break;
511    case ir_var_shader_out:
512    case ir_var_shader_storage:
513       break;
514    default:
515       /* The only variables that are added using this function should be
516        * uniforms, shader storage, shader inputs, and shader outputs, constants
517        * (which use ir_var_auto), and system values.
518        */
519       assert(0);
520       break;
521    }
522 
523    var->data.location = slot;
524    var->data.explicit_location = (slot >= 0);
525    var->data.explicit_index = 0;
526 
527    /* Once the variable is created an initialized, add it to the symbol table
528     * and add the declaration to the IR stream.
529     */
530    instructions->push_tail(var);
531 
532    symtab->add_variable(var);
533    return var;
534 }
535 
536 extern "C" const struct gl_builtin_uniform_desc *
_mesa_glsl_get_builtin_uniform_desc(const char * name)537 _mesa_glsl_get_builtin_uniform_desc(const char *name)
538 {
539    for (unsigned i = 0; _mesa_builtin_uniform_desc[i].name != NULL; i++) {
540       if (strcmp(_mesa_builtin_uniform_desc[i].name, name) == 0) {
541          return &_mesa_builtin_uniform_desc[i];
542       }
543    }
544    return NULL;
545 }
546 
547 ir_variable *
add_uniform(const glsl_type * type,const char * name)548 builtin_variable_generator::add_uniform(const glsl_type *type,
549                                         const char *name)
550 {
551    ir_variable *const uni = add_variable(name, type, ir_var_uniform, -1);
552 
553    const struct gl_builtin_uniform_desc* const statevar =
554       _mesa_glsl_get_builtin_uniform_desc(name);
555    assert(statevar != NULL);
556 
557    const unsigned array_count = type->is_array() ? type->length : 1;
558 
559    ir_state_slot *slots =
560       uni->allocate_state_slots(array_count * statevar->num_elements);
561 
562    for (unsigned a = 0; a < array_count; a++) {
563       for (unsigned j = 0; j < statevar->num_elements; j++) {
564 	 const struct gl_builtin_uniform_element *element =
565 	    &statevar->elements[j];
566 
567 	 memcpy(slots->tokens, element->tokens, sizeof(element->tokens));
568 	 if (type->is_array()) {
569 	    if (strcmp(name, "gl_CurrentAttribVertMESA") == 0 ||
570 		strcmp(name, "gl_CurrentAttribFragMESA") == 0) {
571 	       slots->tokens[2] = a;
572 	    } else {
573 	       slots->tokens[1] = a;
574 	    }
575 	 }
576 
577 	 slots->swizzle = element->swizzle;
578 	 slots++;
579       }
580    }
581 
582    return uni;
583 }
584 
585 
586 ir_variable *
add_const(const char * name,int value)587 builtin_variable_generator::add_const(const char *name, int value)
588 {
589    ir_variable *const var = add_variable(name, glsl_type::int_type,
590 					 ir_var_auto, -1);
591    var->constant_value = new(var) ir_constant(value);
592    var->constant_initializer = new(var) ir_constant(value);
593    var->data.has_initializer = true;
594    return var;
595 }
596 
597 
598 ir_variable *
add_const_ivec3(const char * name,int x,int y,int z)599 builtin_variable_generator::add_const_ivec3(const char *name, int x, int y,
600                                             int z)
601 {
602    ir_variable *const var = add_variable(name, glsl_type::ivec3_type,
603                                          ir_var_auto, -1);
604    ir_constant_data data;
605    memset(&data, 0, sizeof(data));
606    data.i[0] = x;
607    data.i[1] = y;
608    data.i[2] = z;
609    var->constant_value = new(var) ir_constant(glsl_type::ivec3_type, &data);
610    var->constant_initializer =
611       new(var) ir_constant(glsl_type::ivec3_type, &data);
612    var->data.has_initializer = true;
613    return var;
614 }
615 
616 
617 void
generate_constants()618 builtin_variable_generator::generate_constants()
619 {
620    add_const("gl_MaxVertexAttribs", state->Const.MaxVertexAttribs);
621    add_const("gl_MaxVertexTextureImageUnits",
622              state->Const.MaxVertexTextureImageUnits);
623    add_const("gl_MaxCombinedTextureImageUnits",
624              state->Const.MaxCombinedTextureImageUnits);
625    add_const("gl_MaxTextureImageUnits", state->Const.MaxTextureImageUnits);
626    add_const("gl_MaxDrawBuffers", state->Const.MaxDrawBuffers);
627 
628    /* Max uniforms/varyings: GLSL ES counts these in units of vectors; desktop
629     * GL counts them in units of "components" or "floats" and also in units
630     * of vectors since GL 4.1
631     */
632    if (!state->es_shader) {
633       add_const("gl_MaxFragmentUniformComponents",
634                 state->Const.MaxFragmentUniformComponents);
635       add_const("gl_MaxVertexUniformComponents",
636                 state->Const.MaxVertexUniformComponents);
637    }
638 
639    if (state->is_version(410, 100)) {
640       add_const("gl_MaxVertexUniformVectors",
641                 state->Const.MaxVertexUniformComponents / 4);
642       add_const("gl_MaxFragmentUniformVectors",
643                 state->Const.MaxFragmentUniformComponents / 4);
644 
645       /* In GLSL ES 3.00, gl_MaxVaryingVectors was split out to separate
646        * vertex and fragment shader constants.
647        */
648       if (state->is_version(0, 300)) {
649          add_const("gl_MaxVertexOutputVectors",
650                    state->ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents / 4);
651          add_const("gl_MaxFragmentInputVectors",
652                    state->ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents / 4);
653       } else {
654          add_const("gl_MaxVaryingVectors",
655                    state->ctx->Const.MaxVarying);
656       }
657 
658       /* EXT_blend_func_extended brings a built in constant
659        * for determining number of dual source draw buffers
660        */
661       if (state->EXT_blend_func_extended_enable) {
662          add_const("gl_MaxDualSourceDrawBuffersEXT",
663                    state->Const.MaxDualSourceDrawBuffers);
664       }
665    } else {
666       /* Note: gl_MaxVaryingFloats was deprecated in GLSL 1.30+, but not
667        * removed
668        */
669       add_const("gl_MaxVaryingFloats", state->ctx->Const.MaxVarying * 4);
670    }
671 
672    /* Texel offsets were introduced in ARB_shading_language_420pack (which
673     * requires desktop GLSL version 130), and adopted into desktop GLSL
674     * version 4.20 and GLSL ES version 3.00.
675     */
676    if ((state->is_version(130, 0) &&
677         state->ARB_shading_language_420pack_enable) ||
678       state->is_version(420, 300)) {
679       add_const("gl_MinProgramTexelOffset",
680                 state->Const.MinProgramTexelOffset);
681       add_const("gl_MaxProgramTexelOffset",
682                 state->Const.MaxProgramTexelOffset);
683    }
684 
685    if (state->has_clip_distance()) {
686       add_const("gl_MaxClipDistances", state->Const.MaxClipPlanes);
687    }
688    if (state->is_version(130, 0)) {
689       add_const("gl_MaxVaryingComponents", state->ctx->Const.MaxVarying * 4);
690    }
691    if (state->has_cull_distance()) {
692       add_const("gl_MaxCullDistances", state->Const.MaxClipPlanes);
693       add_const("gl_MaxCombinedClipAndCullDistances",
694                 state->Const.MaxClipPlanes);
695    }
696 
697    if (state->has_geometry_shader()) {
698       add_const("gl_MaxVertexOutputComponents",
699                 state->Const.MaxVertexOutputComponents);
700       add_const("gl_MaxGeometryInputComponents",
701                 state->Const.MaxGeometryInputComponents);
702       add_const("gl_MaxGeometryOutputComponents",
703                 state->Const.MaxGeometryOutputComponents);
704       add_const("gl_MaxFragmentInputComponents",
705                 state->Const.MaxFragmentInputComponents);
706       add_const("gl_MaxGeometryTextureImageUnits",
707                 state->Const.MaxGeometryTextureImageUnits);
708       add_const("gl_MaxGeometryOutputVertices",
709                 state->Const.MaxGeometryOutputVertices);
710       add_const("gl_MaxGeometryTotalOutputComponents",
711                 state->Const.MaxGeometryTotalOutputComponents);
712       add_const("gl_MaxGeometryUniformComponents",
713                 state->Const.MaxGeometryUniformComponents);
714 
715       /* Note: the GLSL 1.50-4.40 specs require
716        * gl_MaxGeometryVaryingComponents to be present, and to be at least 64.
717        * But they do not define what it means (and there does not appear to be
718        * any corresponding constant in the GL specs).  However,
719        * ARB_geometry_shader4 defines MAX_GEOMETRY_VARYING_COMPONENTS_ARB to
720        * be the maximum number of components available for use as geometry
721        * outputs.  So we assume this is a synonym for
722        * gl_MaxGeometryOutputComponents.
723        */
724       add_const("gl_MaxGeometryVaryingComponents",
725                 state->Const.MaxGeometryOutputComponents);
726    }
727 
728    if (compatibility) {
729       /* Note: gl_MaxLights stopped being listed as an explicit constant in
730        * GLSL 1.30, however it continues to be referred to (as a minimum size
731        * for compatibility-mode uniforms) all the way up through GLSL 4.30, so
732        * this seems like it was probably an oversight.
733        */
734       add_const("gl_MaxLights", state->Const.MaxLights);
735 
736       add_const("gl_MaxClipPlanes", state->Const.MaxClipPlanes);
737 
738       /* Note: gl_MaxTextureUnits wasn't made compatibility-only until GLSL
739        * 1.50, however this seems like it was probably an oversight.
740        */
741       add_const("gl_MaxTextureUnits", state->Const.MaxTextureUnits);
742 
743       /* Note: gl_MaxTextureCoords was left out of GLSL 1.40, but it was
744        * re-introduced in GLSL 1.50, so this seems like it was probably an
745        * oversight.
746        */
747       add_const("gl_MaxTextureCoords", state->Const.MaxTextureCoords);
748    }
749 
750    if (state->has_atomic_counters()) {
751       add_const("gl_MaxVertexAtomicCounters",
752                 state->Const.MaxVertexAtomicCounters);
753       add_const("gl_MaxFragmentAtomicCounters",
754                 state->Const.MaxFragmentAtomicCounters);
755       add_const("gl_MaxCombinedAtomicCounters",
756                 state->Const.MaxCombinedAtomicCounters);
757       add_const("gl_MaxAtomicCounterBindings",
758                 state->Const.MaxAtomicBufferBindings);
759 
760       if (state->has_geometry_shader()) {
761          add_const("gl_MaxGeometryAtomicCounters",
762                    state->Const.MaxGeometryAtomicCounters);
763       }
764       if (state->is_version(110, 320)) {
765          add_const("gl_MaxTessControlAtomicCounters",
766                    state->Const.MaxTessControlAtomicCounters);
767          add_const("gl_MaxTessEvaluationAtomicCounters",
768                    state->Const.MaxTessEvaluationAtomicCounters);
769       }
770    }
771 
772    if (state->is_version(420, 310)) {
773       add_const("gl_MaxVertexAtomicCounterBuffers",
774                 state->Const.MaxVertexAtomicCounterBuffers);
775       add_const("gl_MaxFragmentAtomicCounterBuffers",
776                 state->Const.MaxFragmentAtomicCounterBuffers);
777       add_const("gl_MaxCombinedAtomicCounterBuffers",
778                 state->Const.MaxCombinedAtomicCounterBuffers);
779       add_const("gl_MaxAtomicCounterBufferSize",
780                 state->Const.MaxAtomicCounterBufferSize);
781 
782       if (state->has_geometry_shader()) {
783          add_const("gl_MaxGeometryAtomicCounterBuffers",
784                    state->Const.MaxGeometryAtomicCounterBuffers);
785       }
786       if (state->is_version(110, 320)) {
787          add_const("gl_MaxTessControlAtomicCounterBuffers",
788                    state->Const.MaxTessControlAtomicCounterBuffers);
789          add_const("gl_MaxTessEvaluationAtomicCounterBuffers",
790                    state->Const.MaxTessEvaluationAtomicCounterBuffers);
791       }
792    }
793 
794    if (state->is_version(430, 310) || state->ARB_compute_shader_enable) {
795       add_const("gl_MaxComputeAtomicCounterBuffers",
796                 state->Const.MaxComputeAtomicCounterBuffers);
797       add_const("gl_MaxComputeAtomicCounters",
798                 state->Const.MaxComputeAtomicCounters);
799       add_const("gl_MaxComputeImageUniforms",
800                 state->Const.MaxComputeImageUniforms);
801       add_const("gl_MaxComputeTextureImageUnits",
802                 state->Const.MaxComputeTextureImageUnits);
803       add_const("gl_MaxComputeUniformComponents",
804                 state->Const.MaxComputeUniformComponents);
805 
806       add_const_ivec3("gl_MaxComputeWorkGroupCount",
807                       state->Const.MaxComputeWorkGroupCount[0],
808                       state->Const.MaxComputeWorkGroupCount[1],
809                       state->Const.MaxComputeWorkGroupCount[2]);
810       add_const_ivec3("gl_MaxComputeWorkGroupSize",
811                       state->Const.MaxComputeWorkGroupSize[0],
812                       state->Const.MaxComputeWorkGroupSize[1],
813                       state->Const.MaxComputeWorkGroupSize[2]);
814 
815       /* From the GLSL 4.40 spec, section 7.1 (Built-In Language Variables):
816        *
817        *     The built-in constant gl_WorkGroupSize is a compute-shader
818        *     constant containing the local work-group size of the shader.  The
819        *     size of the work group in the X, Y, and Z dimensions is stored in
820        *     the x, y, and z components.  The constants values in
821        *     gl_WorkGroupSize will match those specified in the required
822        *     local_size_x, local_size_y, and local_size_z layout qualifiers
823        *     for the current shader.  This is a constant so that it can be
824        *     used to size arrays of memory that can be shared within the local
825        *     work group.  It is a compile-time error to use gl_WorkGroupSize
826        *     in a shader that does not declare a fixed local group size, or
827        *     before that shader has declared a fixed local group size, using
828        *     local_size_x, local_size_y, and local_size_z.
829        *
830        * To prevent the shader from trying to refer to gl_WorkGroupSize before
831        * the layout declaration, we don't define it here.  Intead we define it
832        * in ast_cs_input_layout::hir().
833        */
834    }
835 
836    if (state->has_enhanced_layouts()) {
837       add_const("gl_MaxTransformFeedbackBuffers",
838                 state->Const.MaxTransformFeedbackBuffers);
839       add_const("gl_MaxTransformFeedbackInterleavedComponents",
840                 state->Const.MaxTransformFeedbackInterleavedComponents);
841    }
842 
843    if (state->has_shader_image_load_store()) {
844       add_const("gl_MaxImageUnits",
845                 state->Const.MaxImageUnits);
846       add_const("gl_MaxVertexImageUniforms",
847                 state->Const.MaxVertexImageUniforms);
848       add_const("gl_MaxFragmentImageUniforms",
849                 state->Const.MaxFragmentImageUniforms);
850       add_const("gl_MaxCombinedImageUniforms",
851                 state->Const.MaxCombinedImageUniforms);
852 
853       if (state->has_geometry_shader()) {
854          add_const("gl_MaxGeometryImageUniforms",
855                    state->Const.MaxGeometryImageUniforms);
856       }
857 
858       if (!state->es_shader) {
859          add_const("gl_MaxCombinedImageUnitsAndFragmentOutputs",
860                    state->Const.MaxCombinedShaderOutputResources);
861          add_const("gl_MaxImageSamples",
862                    state->Const.MaxImageSamples);
863       }
864 
865       if (state->has_tessellation_shader()) {
866          add_const("gl_MaxTessControlImageUniforms",
867                    state->Const.MaxTessControlImageUniforms);
868          add_const("gl_MaxTessEvaluationImageUniforms",
869                    state->Const.MaxTessEvaluationImageUniforms);
870       }
871    }
872 
873    if (state->is_version(440, 310) ||
874        state->ARB_ES3_1_compatibility_enable) {
875       add_const("gl_MaxCombinedShaderOutputResources",
876                 state->Const.MaxCombinedShaderOutputResources);
877    }
878 
879    if (state->is_version(410, 0) ||
880        state->ARB_viewport_array_enable ||
881        state->OES_viewport_array_enable)
882       add_const("gl_MaxViewports", state->Const.MaxViewports);
883 
884    if (state->has_tessellation_shader()) {
885       add_const("gl_MaxPatchVertices", state->Const.MaxPatchVertices);
886       add_const("gl_MaxTessGenLevel", state->Const.MaxTessGenLevel);
887       add_const("gl_MaxTessControlInputComponents", state->Const.MaxTessControlInputComponents);
888       add_const("gl_MaxTessControlOutputComponents", state->Const.MaxTessControlOutputComponents);
889       add_const("gl_MaxTessControlTextureImageUnits", state->Const.MaxTessControlTextureImageUnits);
890       add_const("gl_MaxTessEvaluationInputComponents", state->Const.MaxTessEvaluationInputComponents);
891       add_const("gl_MaxTessEvaluationOutputComponents", state->Const.MaxTessEvaluationOutputComponents);
892       add_const("gl_MaxTessEvaluationTextureImageUnits", state->Const.MaxTessEvaluationTextureImageUnits);
893       add_const("gl_MaxTessPatchComponents", state->Const.MaxTessPatchComponents);
894       add_const("gl_MaxTessControlTotalOutputComponents", state->Const.MaxTessControlTotalOutputComponents);
895       add_const("gl_MaxTessControlUniformComponents", state->Const.MaxTessControlUniformComponents);
896       add_const("gl_MaxTessEvaluationUniformComponents", state->Const.MaxTessEvaluationUniformComponents);
897    }
898 
899    if (state->is_version(450, 320) ||
900        state->OES_sample_variables_enable ||
901        state->ARB_ES3_1_compatibility_enable)
902       add_const("gl_MaxSamples", state->Const.MaxSamples);
903 }
904 
905 
906 /**
907  * Generate uniform variables (which exist in all types of shaders).
908  */
909 void
generate_uniforms()910 builtin_variable_generator::generate_uniforms()
911 {
912    if (state->is_version(400, 320) ||
913        state->ARB_sample_shading_enable ||
914        state->OES_sample_variables_enable)
915       add_uniform(int_t, "gl_NumSamples");
916    add_uniform(type("gl_DepthRangeParameters"), "gl_DepthRange");
917    add_uniform(array(vec4_t, VERT_ATTRIB_MAX), "gl_CurrentAttribVertMESA");
918    add_uniform(array(vec4_t, VARYING_SLOT_MAX), "gl_CurrentAttribFragMESA");
919 
920    if (compatibility) {
921       add_uniform(mat4_t, "gl_ModelViewMatrix");
922       add_uniform(mat4_t, "gl_ProjectionMatrix");
923       add_uniform(mat4_t, "gl_ModelViewProjectionMatrix");
924       add_uniform(mat3_t, "gl_NormalMatrix");
925       add_uniform(mat4_t, "gl_ModelViewMatrixInverse");
926       add_uniform(mat4_t, "gl_ProjectionMatrixInverse");
927       add_uniform(mat4_t, "gl_ModelViewProjectionMatrixInverse");
928       add_uniform(mat4_t, "gl_ModelViewMatrixTranspose");
929       add_uniform(mat4_t, "gl_ProjectionMatrixTranspose");
930       add_uniform(mat4_t, "gl_ModelViewProjectionMatrixTranspose");
931       add_uniform(mat4_t, "gl_ModelViewMatrixInverseTranspose");
932       add_uniform(mat4_t, "gl_ProjectionMatrixInverseTranspose");
933       add_uniform(mat4_t, "gl_ModelViewProjectionMatrixInverseTranspose");
934       add_uniform(float_t, "gl_NormalScale");
935       add_uniform(type("gl_LightModelParameters"), "gl_LightModel");
936       add_uniform(vec4_t, "gl_FogParamsOptimizedMESA");
937 
938       const glsl_type *const mat4_array_type =
939 	 array(mat4_t, state->Const.MaxTextureCoords);
940       add_uniform(mat4_array_type, "gl_TextureMatrix");
941       add_uniform(mat4_array_type, "gl_TextureMatrixInverse");
942       add_uniform(mat4_array_type, "gl_TextureMatrixTranspose");
943       add_uniform(mat4_array_type, "gl_TextureMatrixInverseTranspose");
944 
945       add_uniform(array(vec4_t, state->Const.MaxClipPlanes), "gl_ClipPlane");
946       add_uniform(type("gl_PointParameters"), "gl_Point");
947 
948       const glsl_type *const material_parameters_type =
949 	 type("gl_MaterialParameters");
950       add_uniform(material_parameters_type, "gl_FrontMaterial");
951       add_uniform(material_parameters_type, "gl_BackMaterial");
952 
953       add_uniform(array(type("gl_LightSourceParameters"),
954                         state->Const.MaxLights),
955                   "gl_LightSource");
956 
957       const glsl_type *const light_model_products_type =
958          type("gl_LightModelProducts");
959       add_uniform(light_model_products_type, "gl_FrontLightModelProduct");
960       add_uniform(light_model_products_type, "gl_BackLightModelProduct");
961 
962       const glsl_type *const light_products_type =
963          array(type("gl_LightProducts"), state->Const.MaxLights);
964       add_uniform(light_products_type, "gl_FrontLightProduct");
965       add_uniform(light_products_type, "gl_BackLightProduct");
966 
967       add_uniform(array(vec4_t, state->Const.MaxTextureUnits),
968                   "gl_TextureEnvColor");
969 
970       const glsl_type *const texcoords_vec4 =
971 	 array(vec4_t, state->Const.MaxTextureCoords);
972       add_uniform(texcoords_vec4, "gl_EyePlaneS");
973       add_uniform(texcoords_vec4, "gl_EyePlaneT");
974       add_uniform(texcoords_vec4, "gl_EyePlaneR");
975       add_uniform(texcoords_vec4, "gl_EyePlaneQ");
976       add_uniform(texcoords_vec4, "gl_ObjectPlaneS");
977       add_uniform(texcoords_vec4, "gl_ObjectPlaneT");
978       add_uniform(texcoords_vec4, "gl_ObjectPlaneR");
979       add_uniform(texcoords_vec4, "gl_ObjectPlaneQ");
980 
981       add_uniform(type("gl_FogParameters"), "gl_Fog");
982    }
983 }
984 
985 
986 /**
987  * Generate special variables which exist in all shaders.
988  */
989 void
generate_special_vars()990 builtin_variable_generator::generate_special_vars()
991 {
992    if (state->ARB_shader_ballot_enable) {
993       add_system_value(SYSTEM_VALUE_SUBGROUP_SIZE, uint_t, "gl_SubGroupSizeARB");
994       add_system_value(SYSTEM_VALUE_SUBGROUP_INVOCATION, uint_t, "gl_SubGroupInvocationARB");
995       add_system_value(SYSTEM_VALUE_SUBGROUP_EQ_MASK, uint64_t, "gl_SubGroupEqMaskARB");
996       add_system_value(SYSTEM_VALUE_SUBGROUP_GE_MASK, uint64_t, "gl_SubGroupGeMaskARB");
997       add_system_value(SYSTEM_VALUE_SUBGROUP_GT_MASK, uint64_t, "gl_SubGroupGtMaskARB");
998       add_system_value(SYSTEM_VALUE_SUBGROUP_LE_MASK, uint64_t, "gl_SubGroupLeMaskARB");
999       add_system_value(SYSTEM_VALUE_SUBGROUP_LT_MASK, uint64_t, "gl_SubGroupLtMaskARB");
1000    }
1001 }
1002 
1003 
1004 /**
1005  * Generate variables which only exist in vertex shaders.
1006  */
1007 void
generate_vs_special_vars()1008 builtin_variable_generator::generate_vs_special_vars()
1009 {
1010    ir_variable *var;
1011 
1012    if (state->is_version(130, 300))
1013       add_system_value(SYSTEM_VALUE_VERTEX_ID, int_t, "gl_VertexID");
1014    if (state->is_version(460, 0)) {
1015       add_system_value(SYSTEM_VALUE_BASE_VERTEX, int_t, "gl_BaseVertex");
1016       add_system_value(SYSTEM_VALUE_BASE_INSTANCE, int_t, "gl_BaseInstance");
1017       add_system_value(SYSTEM_VALUE_DRAW_ID, int_t, "gl_DrawID");
1018    }
1019    if (state->ARB_draw_instanced_enable)
1020       add_system_value(SYSTEM_VALUE_INSTANCE_ID, int_t, "gl_InstanceIDARB");
1021    if (state->ARB_draw_instanced_enable || state->is_version(140, 300))
1022       add_system_value(SYSTEM_VALUE_INSTANCE_ID, int_t, "gl_InstanceID");
1023    if (state->ARB_shader_draw_parameters_enable) {
1024       add_system_value(SYSTEM_VALUE_BASE_VERTEX, int_t, "gl_BaseVertexARB");
1025       add_system_value(SYSTEM_VALUE_BASE_INSTANCE, int_t, "gl_BaseInstanceARB");
1026       add_system_value(SYSTEM_VALUE_DRAW_ID, int_t, "gl_DrawIDARB");
1027    }
1028    if (state->AMD_vertex_shader_layer_enable ||
1029        state->ARB_shader_viewport_layer_array_enable) {
1030       var = add_output(VARYING_SLOT_LAYER, int_t, "gl_Layer");
1031       var->data.interpolation = INTERP_MODE_FLAT;
1032    }
1033    if (state->AMD_vertex_shader_viewport_index_enable ||
1034        state->ARB_shader_viewport_layer_array_enable) {
1035       var = add_output(VARYING_SLOT_VIEWPORT, int_t, "gl_ViewportIndex");
1036       var->data.interpolation = INTERP_MODE_FLAT;
1037    }
1038    if (compatibility) {
1039       add_input(VERT_ATTRIB_POS, vec4_t, "gl_Vertex");
1040       add_input(VERT_ATTRIB_NORMAL, vec3_t, "gl_Normal");
1041       add_input(VERT_ATTRIB_COLOR0, vec4_t, "gl_Color");
1042       add_input(VERT_ATTRIB_COLOR1, vec4_t, "gl_SecondaryColor");
1043       add_input(VERT_ATTRIB_TEX0, vec4_t, "gl_MultiTexCoord0");
1044       add_input(VERT_ATTRIB_TEX1, vec4_t, "gl_MultiTexCoord1");
1045       add_input(VERT_ATTRIB_TEX2, vec4_t, "gl_MultiTexCoord2");
1046       add_input(VERT_ATTRIB_TEX3, vec4_t, "gl_MultiTexCoord3");
1047       add_input(VERT_ATTRIB_TEX4, vec4_t, "gl_MultiTexCoord4");
1048       add_input(VERT_ATTRIB_TEX5, vec4_t, "gl_MultiTexCoord5");
1049       add_input(VERT_ATTRIB_TEX6, vec4_t, "gl_MultiTexCoord6");
1050       add_input(VERT_ATTRIB_TEX7, vec4_t, "gl_MultiTexCoord7");
1051       add_input(VERT_ATTRIB_FOG, float_t, "gl_FogCoord");
1052    }
1053 }
1054 
1055 
1056 /**
1057  * Generate variables which only exist in tessellation control shaders.
1058  */
1059 void
generate_tcs_special_vars()1060 builtin_variable_generator::generate_tcs_special_vars()
1061 {
1062    add_system_value(SYSTEM_VALUE_PRIMITIVE_ID, int_t, "gl_PrimitiveID");
1063    add_system_value(SYSTEM_VALUE_INVOCATION_ID, int_t, "gl_InvocationID");
1064    add_system_value(SYSTEM_VALUE_VERTICES_IN, int_t, "gl_PatchVerticesIn");
1065 
1066    add_output(VARYING_SLOT_TESS_LEVEL_OUTER, array(float_t, 4),
1067               "gl_TessLevelOuter")->data.patch = 1;
1068    add_output(VARYING_SLOT_TESS_LEVEL_INNER, array(float_t, 2),
1069               "gl_TessLevelInner")->data.patch = 1;
1070    /* XXX What to do if multiple are flipped on? */
1071    int bbox_slot = state->ctx->Const.NoPrimitiveBoundingBoxOutput ? -1 :
1072       VARYING_SLOT_BOUNDING_BOX0;
1073    if (state->EXT_primitive_bounding_box_enable)
1074       add_output(bbox_slot, array(vec4_t, 2), "gl_BoundingBoxEXT")
1075          ->data.patch = 1;
1076    if (state->OES_primitive_bounding_box_enable)
1077       add_output(bbox_slot, array(vec4_t, 2), "gl_BoundingBoxOES")
1078          ->data.patch = 1;
1079    if (state->is_version(0, 320) || state->ARB_ES3_2_compatibility_enable)
1080       add_output(bbox_slot, array(vec4_t, 2), "gl_BoundingBox")
1081          ->data.patch = 1;
1082 }
1083 
1084 
1085 /**
1086  * Generate variables which only exist in tessellation evaluation shaders.
1087  */
1088 void
generate_tes_special_vars()1089 builtin_variable_generator::generate_tes_special_vars()
1090 {
1091    ir_variable *var;
1092 
1093    add_system_value(SYSTEM_VALUE_PRIMITIVE_ID, int_t, "gl_PrimitiveID");
1094    add_system_value(SYSTEM_VALUE_VERTICES_IN, int_t, "gl_PatchVerticesIn");
1095    add_system_value(SYSTEM_VALUE_TESS_COORD, vec3_t, "gl_TessCoord");
1096    if (this->state->ctx->Const.GLSLTessLevelsAsInputs) {
1097       add_input(VARYING_SLOT_TESS_LEVEL_OUTER, array(float_t, 4),
1098                 "gl_TessLevelOuter")->data.patch = 1;
1099       add_input(VARYING_SLOT_TESS_LEVEL_INNER, array(float_t, 2),
1100                 "gl_TessLevelInner")->data.patch = 1;
1101    } else {
1102       add_system_value(SYSTEM_VALUE_TESS_LEVEL_OUTER, array(float_t, 4),
1103                        "gl_TessLevelOuter");
1104       add_system_value(SYSTEM_VALUE_TESS_LEVEL_INNER, array(float_t, 2),
1105                        "gl_TessLevelInner");
1106    }
1107    if (state->ARB_shader_viewport_layer_array_enable) {
1108       var = add_output(VARYING_SLOT_LAYER, int_t, "gl_Layer");
1109       var->data.interpolation = INTERP_MODE_FLAT;
1110       var = add_output(VARYING_SLOT_VIEWPORT, int_t, "gl_ViewportIndex");
1111       var->data.interpolation = INTERP_MODE_FLAT;
1112    }
1113 }
1114 
1115 
1116 /**
1117  * Generate variables which only exist in geometry shaders.
1118  */
1119 void
generate_gs_special_vars()1120 builtin_variable_generator::generate_gs_special_vars()
1121 {
1122    ir_variable *var;
1123 
1124    var = add_output(VARYING_SLOT_LAYER, int_t, "gl_Layer");
1125    var->data.interpolation = INTERP_MODE_FLAT;
1126    if (state->is_version(410, 0) || state->ARB_viewport_array_enable ||
1127        state->OES_viewport_array_enable) {
1128       var = add_output(VARYING_SLOT_VIEWPORT, int_t, "gl_ViewportIndex");
1129       var->data.interpolation = INTERP_MODE_FLAT;
1130    }
1131    if (state->is_version(400, 320) || state->ARB_gpu_shader5_enable ||
1132        state->OES_geometry_shader_enable || state->EXT_geometry_shader_enable) {
1133       add_system_value(SYSTEM_VALUE_INVOCATION_ID, int_t, "gl_InvocationID");
1134    }
1135 
1136    /* Although gl_PrimitiveID appears in tessellation control and tessellation
1137     * evaluation shaders, it has a different function there than it has in
1138     * geometry shaders, so we treat it (and its counterpart gl_PrimitiveIDIn)
1139     * as special geometry shader variables.
1140     *
1141     * Note that although the general convention of suffixing geometry shader
1142     * input varyings with "In" was not adopted into GLSL 1.50, it is used in
1143     * the specific case of gl_PrimitiveIDIn.  So we don't need to treat
1144     * gl_PrimitiveIDIn as an {ARB,EXT}_geometry_shader4-only variable.
1145     */
1146    var = add_input(VARYING_SLOT_PRIMITIVE_ID, int_t, "gl_PrimitiveIDIn");
1147    var->data.interpolation = INTERP_MODE_FLAT;
1148    var = add_output(VARYING_SLOT_PRIMITIVE_ID, int_t, "gl_PrimitiveID");
1149    var->data.interpolation = INTERP_MODE_FLAT;
1150 }
1151 
1152 
1153 /**
1154  * Generate variables which only exist in fragment shaders.
1155  */
1156 void
generate_fs_special_vars()1157 builtin_variable_generator::generate_fs_special_vars()
1158 {
1159    ir_variable *var;
1160 
1161    if (this->state->ctx->Const.GLSLFragCoordIsSysVal)
1162       add_system_value(SYSTEM_VALUE_FRAG_COORD, vec4_t, "gl_FragCoord");
1163    else
1164       add_input(VARYING_SLOT_POS, vec4_t, "gl_FragCoord");
1165 
1166    if (this->state->ctx->Const.GLSLFrontFacingIsSysVal)
1167       add_system_value(SYSTEM_VALUE_FRONT_FACE, bool_t, "gl_FrontFacing");
1168    else
1169       add_input(VARYING_SLOT_FACE, bool_t, "gl_FrontFacing");
1170 
1171    if (state->is_version(120, 100))
1172       add_input(VARYING_SLOT_PNTC, vec2_t, "gl_PointCoord");
1173 
1174    if (state->has_geometry_shader()) {
1175       var = add_input(VARYING_SLOT_PRIMITIVE_ID, int_t, "gl_PrimitiveID");
1176       var->data.interpolation = INTERP_MODE_FLAT;
1177    }
1178 
1179    /* gl_FragColor and gl_FragData were deprecated starting in desktop GLSL
1180     * 1.30, and were relegated to the compatibility profile in GLSL 4.20.
1181     * They were removed from GLSL ES 3.00.
1182     */
1183    if (compatibility || !state->is_version(420, 300)) {
1184       add_output(FRAG_RESULT_COLOR, vec4_t, "gl_FragColor");
1185       add_output(FRAG_RESULT_DATA0,
1186                  array(vec4_t, state->Const.MaxDrawBuffers), "gl_FragData");
1187    }
1188 
1189    if (state->has_framebuffer_fetch() && !state->is_version(130, 300)) {
1190       ir_variable *const var =
1191          add_output(FRAG_RESULT_DATA0,
1192                     array(vec4_t, state->Const.MaxDrawBuffers),
1193                     "gl_LastFragData");
1194       var->data.precision = GLSL_PRECISION_MEDIUM;
1195       var->data.read_only = 1;
1196       var->data.fb_fetch_output = 1;
1197    }
1198 
1199    if (state->es_shader && state->language_version == 100 && state->EXT_blend_func_extended_enable) {
1200       add_index_output(FRAG_RESULT_COLOR, 1, vec4_t,
1201                        "gl_SecondaryFragColorEXT");
1202       add_index_output(FRAG_RESULT_DATA0, 1,
1203                        array(vec4_t, state->Const.MaxDualSourceDrawBuffers),
1204                        "gl_SecondaryFragDataEXT");
1205    }
1206 
1207    /* gl_FragDepth has always been in desktop GLSL, but did not appear in GLSL
1208     * ES 1.00.
1209     */
1210    if (state->is_version(110, 300))
1211       add_output(FRAG_RESULT_DEPTH, float_t, "gl_FragDepth");
1212 
1213    if (state->EXT_frag_depth_enable)
1214       add_output(FRAG_RESULT_DEPTH, float_t, "gl_FragDepthEXT");
1215 
1216    if (state->ARB_shader_stencil_export_enable) {
1217       ir_variable *const var =
1218          add_output(FRAG_RESULT_STENCIL, int_t, "gl_FragStencilRefARB");
1219       if (state->ARB_shader_stencil_export_warn)
1220          var->enable_extension_warning("GL_ARB_shader_stencil_export");
1221    }
1222 
1223    if (state->AMD_shader_stencil_export_enable) {
1224       ir_variable *const var =
1225          add_output(FRAG_RESULT_STENCIL, int_t, "gl_FragStencilRefAMD");
1226       if (state->AMD_shader_stencil_export_warn)
1227          var->enable_extension_warning("GL_AMD_shader_stencil_export");
1228    }
1229 
1230    if (state->is_version(400, 320) ||
1231        state->ARB_sample_shading_enable ||
1232        state->OES_sample_variables_enable) {
1233       add_system_value(SYSTEM_VALUE_SAMPLE_ID, int_t, "gl_SampleID");
1234       add_system_value(SYSTEM_VALUE_SAMPLE_POS, vec2_t, "gl_SamplePosition");
1235       /* From the ARB_sample_shading specification:
1236        *    "The number of elements in the array is ceil(<s>/32), where
1237        *    <s> is the maximum number of color samples supported by the
1238        *    implementation."
1239        * Since no drivers expose more than 32x MSAA, we can simply set
1240        * the array size to 1 rather than computing it.
1241        */
1242       add_output(FRAG_RESULT_SAMPLE_MASK, array(int_t, 1), "gl_SampleMask");
1243    }
1244 
1245    if (state->is_version(400, 320) ||
1246        state->ARB_gpu_shader5_enable ||
1247        state->OES_sample_variables_enable) {
1248       add_system_value(SYSTEM_VALUE_SAMPLE_MASK_IN, array(int_t, 1), "gl_SampleMaskIn");
1249    }
1250 
1251    if (state->is_version(430, 320) ||
1252        state->ARB_fragment_layer_viewport_enable ||
1253        state->OES_geometry_shader_enable ||
1254        state->EXT_geometry_shader_enable) {
1255       var = add_input(VARYING_SLOT_LAYER, int_t, "gl_Layer");
1256       var->data.interpolation = INTERP_MODE_FLAT;
1257    }
1258 
1259    if (state->is_version(430, 0) ||
1260        state->ARB_fragment_layer_viewport_enable ||
1261        state->OES_viewport_array_enable) {
1262       var = add_input(VARYING_SLOT_VIEWPORT, int_t, "gl_ViewportIndex");
1263       var->data.interpolation = INTERP_MODE_FLAT;
1264    }
1265 
1266    if (state->is_version(450, 310) || state->ARB_ES3_1_compatibility_enable)
1267       add_system_value(SYSTEM_VALUE_HELPER_INVOCATION, bool_t, "gl_HelperInvocation");
1268 }
1269 
1270 
1271 /**
1272  * Generate variables which only exist in compute shaders.
1273  */
1274 void
generate_cs_special_vars()1275 builtin_variable_generator::generate_cs_special_vars()
1276 {
1277    add_system_value(SYSTEM_VALUE_LOCAL_INVOCATION_ID, uvec3_t,
1278                     "gl_LocalInvocationID");
1279    add_system_value(SYSTEM_VALUE_WORK_GROUP_ID, uvec3_t, "gl_WorkGroupID");
1280    add_system_value(SYSTEM_VALUE_NUM_WORK_GROUPS, uvec3_t, "gl_NumWorkGroups");
1281 
1282    if (state->ARB_compute_variable_group_size_enable) {
1283       add_system_value(SYSTEM_VALUE_LOCAL_GROUP_SIZE,
1284                        uvec3_t, "gl_LocalGroupSizeARB");
1285    }
1286 
1287    add_system_value(SYSTEM_VALUE_GLOBAL_INVOCATION_ID,
1288                     uvec3_t, "gl_GlobalInvocationID");
1289    add_system_value(SYSTEM_VALUE_LOCAL_INVOCATION_INDEX,
1290                     uint_t, "gl_LocalInvocationIndex");
1291 }
1292 
1293 
1294 /**
1295  * Add a single "varying" variable.  The variable's type and direction (input
1296  * or output) are adjusted as appropriate for the type of shader being
1297  * compiled.
1298  */
1299 void
add_varying(int slot,const glsl_type * type,const char * name)1300 builtin_variable_generator::add_varying(int slot, const glsl_type *type,
1301                                         const char *name)
1302 {
1303    switch (state->stage) {
1304    case MESA_SHADER_TESS_CTRL:
1305    case MESA_SHADER_TESS_EVAL:
1306    case MESA_SHADER_GEOMETRY:
1307       this->per_vertex_in.add_field(slot, type, name);
1308       /* FALLTHROUGH */
1309    case MESA_SHADER_VERTEX:
1310       this->per_vertex_out.add_field(slot, type, name);
1311       break;
1312    case MESA_SHADER_FRAGMENT:
1313       add_input(slot, type, name);
1314       break;
1315    case MESA_SHADER_COMPUTE:
1316       /* Compute shaders don't have varyings. */
1317       break;
1318    default:
1319       break;
1320    }
1321 }
1322 
1323 
1324 /**
1325  * Generate variables that are used to communicate data from one shader stage
1326  * to the next ("varyings").
1327  */
1328 void
generate_varyings()1329 builtin_variable_generator::generate_varyings()
1330 {
1331    /* gl_Position and gl_PointSize are not visible from fragment shaders. */
1332    if (state->stage != MESA_SHADER_FRAGMENT) {
1333       add_varying(VARYING_SLOT_POS, vec4_t, "gl_Position");
1334       if (!state->es_shader ||
1335           state->stage == MESA_SHADER_VERTEX ||
1336           (state->stage == MESA_SHADER_GEOMETRY &&
1337            (state->OES_geometry_point_size_enable ||
1338             state->EXT_geometry_point_size_enable)) ||
1339           ((state->stage == MESA_SHADER_TESS_CTRL ||
1340             state->stage == MESA_SHADER_TESS_EVAL) &&
1341            (state->OES_tessellation_point_size_enable ||
1342             state->EXT_tessellation_point_size_enable))) {
1343          add_varying(VARYING_SLOT_PSIZ, float_t, "gl_PointSize");
1344       }
1345    }
1346 
1347    if (state->has_clip_distance()) {
1348        add_varying(VARYING_SLOT_CLIP_DIST0, array(float_t, 0),
1349                    "gl_ClipDistance");
1350    }
1351    if (state->has_cull_distance()) {
1352       add_varying(VARYING_SLOT_CULL_DIST0, array(float_t, 0),
1353                    "gl_CullDistance");
1354    }
1355 
1356    if (compatibility) {
1357       add_varying(VARYING_SLOT_TEX0, array(vec4_t, 0), "gl_TexCoord");
1358       add_varying(VARYING_SLOT_FOGC, float_t, "gl_FogFragCoord");
1359       if (state->stage == MESA_SHADER_FRAGMENT) {
1360          add_varying(VARYING_SLOT_COL0, vec4_t, "gl_Color");
1361          add_varying(VARYING_SLOT_COL1, vec4_t, "gl_SecondaryColor");
1362       } else {
1363          add_varying(VARYING_SLOT_CLIP_VERTEX, vec4_t, "gl_ClipVertex");
1364          add_varying(VARYING_SLOT_COL0, vec4_t, "gl_FrontColor");
1365          add_varying(VARYING_SLOT_BFC0, vec4_t, "gl_BackColor");
1366          add_varying(VARYING_SLOT_COL1, vec4_t, "gl_FrontSecondaryColor");
1367          add_varying(VARYING_SLOT_BFC1, vec4_t, "gl_BackSecondaryColor");
1368       }
1369    }
1370 
1371    /* Section 7.1 (Built-In Language Variables) of the GLSL 4.00 spec
1372     * says:
1373     *
1374     *    "In the tessellation control language, built-in variables are
1375     *    intrinsically declared as:
1376     *
1377     *        in gl_PerVertex {
1378     *            vec4 gl_Position;
1379     *            float gl_PointSize;
1380     *            float gl_ClipDistance[];
1381     *        } gl_in[gl_MaxPatchVertices];"
1382     */
1383    if (state->stage == MESA_SHADER_TESS_CTRL ||
1384        state->stage == MESA_SHADER_TESS_EVAL) {
1385       const glsl_type *per_vertex_in_type =
1386          this->per_vertex_in.construct_interface_instance();
1387       add_variable("gl_in", array(per_vertex_in_type, state->Const.MaxPatchVertices),
1388                    ir_var_shader_in, -1);
1389    }
1390    if (state->stage == MESA_SHADER_GEOMETRY) {
1391       const glsl_type *per_vertex_in_type =
1392          this->per_vertex_in.construct_interface_instance();
1393       add_variable("gl_in", array(per_vertex_in_type, 0),
1394                    ir_var_shader_in, -1);
1395    }
1396    if (state->stage == MESA_SHADER_TESS_CTRL) {
1397       const glsl_type *per_vertex_out_type =
1398          this->per_vertex_out.construct_interface_instance();
1399       add_variable("gl_out", array(per_vertex_out_type, 0),
1400                    ir_var_shader_out, -1);
1401    }
1402    if (state->stage == MESA_SHADER_VERTEX ||
1403        state->stage == MESA_SHADER_TESS_EVAL ||
1404        state->stage == MESA_SHADER_GEOMETRY) {
1405       const glsl_type *per_vertex_out_type =
1406          this->per_vertex_out.construct_interface_instance();
1407       const glsl_struct_field *fields = per_vertex_out_type->fields.structure;
1408       for (unsigned i = 0; i < per_vertex_out_type->length; i++) {
1409          ir_variable *var =
1410             add_variable(fields[i].name, fields[i].type, ir_var_shader_out,
1411                          fields[i].location);
1412          var->data.interpolation = fields[i].interpolation;
1413          var->data.centroid = fields[i].centroid;
1414          var->data.sample = fields[i].sample;
1415          var->data.patch = fields[i].patch;
1416          var->data.precision = fields[i].precision;
1417          var->init_interface_type(per_vertex_out_type);
1418       }
1419    }
1420 }
1421 
1422 
1423 }; /* Anonymous namespace */
1424 
1425 
1426 void
_mesa_glsl_initialize_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state)1427 _mesa_glsl_initialize_variables(exec_list *instructions,
1428 				struct _mesa_glsl_parse_state *state)
1429 {
1430    builtin_variable_generator gen(instructions, state);
1431 
1432    gen.generate_constants();
1433    gen.generate_uniforms();
1434    gen.generate_special_vars();
1435 
1436    gen.generate_varyings();
1437 
1438    switch (state->stage) {
1439    case MESA_SHADER_VERTEX:
1440       gen.generate_vs_special_vars();
1441       break;
1442    case MESA_SHADER_TESS_CTRL:
1443       gen.generate_tcs_special_vars();
1444       break;
1445    case MESA_SHADER_TESS_EVAL:
1446       gen.generate_tes_special_vars();
1447       break;
1448    case MESA_SHADER_GEOMETRY:
1449       gen.generate_gs_special_vars();
1450       break;
1451    case MESA_SHADER_FRAGMENT:
1452       gen.generate_fs_special_vars();
1453       break;
1454    case MESA_SHADER_COMPUTE:
1455       gen.generate_cs_special_vars();
1456       break;
1457    default:
1458       break;
1459    }
1460 }
1461