src/glsl/ir_variable.cpp

   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 "glsl_parser_extras.h"
  26 #include "glsl_symbol_table.h"
  27 #include "builtin_variables.h"
  28 #include "main/uniforms.h"
  29 #include "program/prog_parameter.h"
  30 #include "program/prog_statevars.h"
  31 #include "program/prog_instruction.h"
  32
  33 static void generate_ARB_draw_buffers_variables(exec_list *,
  34                                                 struct _mesa_glsl_parse_state *,
  35                                                 bool, _mesa_glsl_parser_targets);
  36
  37 static void
  38 generate_ARB_draw_instanced_variables(exec_list *,
  39                                       struct _mesa_glsl_parse_state *,
  40                                       bool, _mesa_glsl_parser_targets);
  41
  42 static struct gl_builtin_uniform_element gl_DepthRange_elements[] = {
  43    {"near", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_XXXX},
  44    {"far", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_YYYY},
  45    {"diff", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_ZZZZ},
  46 };
  47
  48 static struct gl_builtin_uniform_element gl_ClipPlane_elements[] = {
  49    {NULL, {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW}
  50 };
  51
  52 static struct gl_builtin_uniform_element gl_Point_elements[] = {
  53    {"size", {STATE_POINT_SIZE}, SWIZZLE_XXXX},
  54    {"sizeMin", {STATE_POINT_SIZE}, SWIZZLE_YYYY},
  55    {"sizeMax", {STATE_POINT_SIZE}, SWIZZLE_ZZZZ},
  56    {"fadeThresholdSize", {STATE_POINT_SIZE}, SWIZZLE_WWWW},
  57    {"distanceConstantAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_XXXX},
  58    {"distanceLinearAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_YYYY},
  59    {"distanceQuadraticAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_ZZZZ},
  60 };
  61
  62 static struct gl_builtin_uniform_element gl_FrontMaterial_elements[] = {
  63    {"emission", {STATE_MATERIAL, 0, STATE_EMISSION}, SWIZZLE_XYZW},
  64    {"ambient", {STATE_MATERIAL, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
  65    {"diffuse", {STATE_MATERIAL, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
  66    {"specular", {STATE_MATERIAL, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
  67    {"shininess", {STATE_MATERIAL, 0, STATE_SHININESS}, SWIZZLE_XXXX},
  68 };
  69
  70 static struct gl_builtin_uniform_element gl_BackMaterial_elements[] = {
  71    {"emission", {STATE_MATERIAL, 1, STATE_EMISSION}, SWIZZLE_XYZW},
  72    {"ambient", {STATE_MATERIAL, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
  73    {"diffuse", {STATE_MATERIAL, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
  74    {"specular", {STATE_MATERIAL, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
  75    {"shininess", {STATE_MATERIAL, 1, STATE_SHININESS}, SWIZZLE_XXXX},
  76 };
  77
  78 static struct gl_builtin_uniform_element gl_LightSource_elements[] = {
  79    {"ambient", {STATE_LIGHT, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
  80    {"diffuse", {STATE_LIGHT, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
  81    {"specular", {STATE_LIGHT, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
  82    {"position", {STATE_LIGHT, 0, STATE_POSITION}, SWIZZLE_XYZW},
  83    {"halfVector", {STATE_LIGHT, 0, STATE_HALF_VECTOR}, SWIZZLE_XYZW},
  84    {"spotDirection", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION},
  85     MAKE_SWIZZLE4(SWIZZLE_X,
  86                   SWIZZLE_Y,
  87                   SWIZZLE_Z,
  88                   SWIZZLE_Z)},
  89    {"spotCosCutoff", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_WWWW},
  90    {"spotCutoff", {STATE_LIGHT, 0, STATE_SPOT_CUTOFF}, SWIZZLE_XXXX},
  91    {"spotExponent", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_WWWW},
  92    {"constantAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_XXXX},
  93    {"linearAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_YYYY},
  94    {"quadraticAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_ZZZZ},
  95 };
  96
  97 static struct gl_builtin_uniform_element gl_LightModel_elements[] = {
  98    {"ambient", {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW},
  99 };
 100
 101 static struct gl_builtin_uniform_element gl_FrontLightModelProduct_elements[] = {
 102    {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW},
 103 };
 104
 105 static struct gl_builtin_uniform_element gl_BackLightModelProduct_elements[] = {
 106    {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW},
 107 };
 108
 109 static struct gl_builtin_uniform_element gl_FrontLightProduct_elements[] = {
 110    {"ambient", {STATE_LIGHTPROD, 0, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
 111    {"diffuse", {STATE_LIGHTPROD, 0, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
 112    {"specular", {STATE_LIGHTPROD, 0, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
 113 };
 114
 115 static struct gl_builtin_uniform_element gl_BackLightProduct_elements[] = {
 116    {"ambient", {STATE_LIGHTPROD, 0, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
 117    {"diffuse", {STATE_LIGHTPROD, 0, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
 118    {"specular", {STATE_LIGHTPROD, 0, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
 119 };
 120
 121 static struct gl_builtin_uniform_element gl_TextureEnvColor_elements[] = {
 122    {NULL, {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW},
 123 };
 124
 125 static struct gl_builtin_uniform_element gl_EyePlaneS_elements[] = {
 126    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW},
 127 };
 128
 129 static struct gl_builtin_uniform_element gl_EyePlaneT_elements[] = {
 130    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW},
 131 };
 132
 133 static struct gl_builtin_uniform_element gl_EyePlaneR_elements[] = {
 134    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW},
 135 };
 136
 137 static struct gl_builtin_uniform_element gl_EyePlaneQ_elements[] = {
 138    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW},
 139 };
 140
 141 static struct gl_builtin_uniform_element gl_ObjectPlaneS_elements[] = {
 142    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW},
 143 };
 144
 145 static struct gl_builtin_uniform_element gl_ObjectPlaneT_elements[] = {
 146    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW},
 147 };
 148
 149 static struct gl_builtin_uniform_element gl_ObjectPlaneR_elements[] = {
 150    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW},
 151 };
 152
 153 static struct gl_builtin_uniform_element gl_ObjectPlaneQ_elements[] = {
 154    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW},
 155 };
 156
 157 static struct gl_builtin_uniform_element gl_Fog_elements[] = {
 158    {"color", {STATE_FOG_COLOR}, SWIZZLE_XYZW},
 159    {"density", {STATE_FOG_PARAMS}, SWIZZLE_XXXX},
 160    {"start", {STATE_FOG_PARAMS}, SWIZZLE_YYYY},
 161    {"end", {STATE_FOG_PARAMS}, SWIZZLE_ZZZZ},
 162    {"scale", {STATE_FOG_PARAMS}, SWIZZLE_WWWW},
 163 };
 164
 165 static struct gl_builtin_uniform_element gl_NormalScale_elements[] = {
 166    {NULL, {STATE_NORMAL_SCALE}, SWIZZLE_XXXX},
 167 };
 168
 169 static struct gl_builtin_uniform_element gl_MESABumpRotMatrix0_elements[] = {
 170    {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_0}, SWIZZLE_XYZW},
 171 };
 172
 173 static struct gl_builtin_uniform_element gl_MESABumpRotMatrix1_elements[] = {
 174    {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_1}, SWIZZLE_XYZW},
 175 };
 176
 177 static struct gl_builtin_uniform_element gl_MESAFogParamsOptimized_elements[] = {
 178    {NULL, {STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED}, SWIZZLE_XYZW},
 179 };
 180
 181 #define MATRIX(name, statevar, modifier)                                \
 182    static struct gl_builtin_uniform_element name ## _elements[] = {     \
 183       { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW },           \
 184       { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW },           \
 185       { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW },           \
 186       { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW },           \
 187    }
 188
 189 MATRIX(gl_ModelViewMatrix,
 190        STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE);
 191 MATRIX(gl_ModelViewMatrixInverse,
 192        STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS);
 193 MATRIX(gl_ModelViewMatrixTranspose,
 194        STATE_MODELVIEW_MATRIX, 0);
 195 MATRIX(gl_ModelViewMatrixInverseTranspose,
 196        STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE);
 197
 198 MATRIX(gl_ProjectionMatrix,
 199        STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE);
 200 MATRIX(gl_ProjectionMatrixInverse,
 201        STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS);
 202 MATRIX(gl_ProjectionMatrixTranspose,
 203        STATE_PROJECTION_MATRIX, 0);
 204 MATRIX(gl_ProjectionMatrixInverseTranspose,
 205        STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE);
 206
 207 MATRIX(gl_ModelViewProjectionMatrix,
 208        STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE);
 209 MATRIX(gl_ModelViewProjectionMatrixInverse,
 210        STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS);
 211 MATRIX(gl_ModelViewProjectionMatrixTranspose,
 212        STATE_MVP_MATRIX, 0);
 213 MATRIX(gl_ModelViewProjectionMatrixInverseTranspose,
 214        STATE_MVP_MATRIX, STATE_MATRIX_INVERSE);
 215
 216 MATRIX(gl_TextureMatrix,
 217        STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE);
 218 MATRIX(gl_TextureMatrixInverse,
 219        STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS);
 220 MATRIX(gl_TextureMatrixTranspose,
 221        STATE_TEXTURE_MATRIX, 0);
 222 MATRIX(gl_TextureMatrixInverseTranspose,
 223        STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE);
 224
 225 static struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = {
 226    { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE},
 227      SWIZZLE_XYZW },
 228    { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE},
 229      SWIZZLE_XYZW },
 230    { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE},
 231      SWIZZLE_XYZW },
 232 };
 233
 234 #undef MATRIX
 235
 236 #define STATEVAR(name) {#name, name ## _elements, Elements(name ## _elements)}
 237
 238 const struct gl_builtin_uniform_desc _mesa_builtin_uniform_desc[] = {
 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_MESABumpRotMatrix0),
 285    STATEVAR(gl_MESABumpRotMatrix1),
 286    STATEVAR(gl_MESAFogParamsOptimized),
 287
 288    {NULL, NULL, 0}
 289 };
 290
 291 static ir_variable *
 292 add_variable(exec_list *instructions, glsl_symbol_table *symtab,
 293              const char *name, const glsl_type *type,
 294              enum ir_variable_mode mode, int slot)
 295 {
 296    ir_variable *var = new(symtab) ir_variable(type, name, mode);
 297
 298    switch (var->mode) {
 299    case ir_var_auto:
 300    case ir_var_in:
 301    case ir_var_const_in:
 302    case ir_var_uniform:
 303    case ir_var_system_value:
 304       var->read_only = true;
 305       break;
 306    case ir_var_inout:
 307    case ir_var_out:
 308       break;
 309    default:
 310       assert(0);
 311       break;
 312    }
 313
 314    var->location = slot;
 315    var->explicit_location = (slot >= 0);
 316
 317    /* Once the variable is created an initialized, add it to the symbol table
 318     * and add the declaration to the IR stream.
 319     */
 320    instructions->push_tail(var);
 321
 322    symtab->add_variable(var);
 323    return var;
 324 }
 325
 326 static ir_variable *
 327 add_uniform(exec_list *instructions, glsl_symbol_table *symtab,
 328             const char *name, const glsl_type *type)
 329 {
 330    ir_variable *const uni =
 331       add_variable(instructions, symtab, name, type, ir_var_uniform, -1);
 332
 333    unsigned i;
 334    for (i = 0; _mesa_builtin_uniform_desc[i].name != NULL; i++) {
 335       if (strcmp(_mesa_builtin_uniform_desc[i].name, name) == 0) {
 336          break;
 337       }
 338    }
 339
 340    assert(_mesa_builtin_uniform_desc[i].name != NULL);
 341    const struct gl_builtin_uniform_desc* const statevar =
 342       &_mesa_builtin_uniform_desc[i];
 343
 344    const unsigned array_count = type->is_array() ? type->length : 1;
 345    uni->num_state_slots = array_count * statevar->num_elements;
 346
 347    ir_state_slot *slots =
 348       ralloc_array(uni, ir_state_slot, uni->num_state_slots);
 349
 350    uni->state_slots = slots;
 351
 352    for (unsigned a = 0; a < array_count; a++) {
 353       for (unsigned j = 0; j < statevar->num_elements; j++) {
 354          struct gl_builtin_uniform_element *element = &statevar->elements[j];
 355
 356          memcpy(slots->tokens, element->tokens, sizeof(element->tokens));
 357          if (type->is_array()) {
 358             slots->tokens[1] = a;
 359          }
 360
 361          slots->swizzle = element->swizzle;
 362          slots++;
 363       }
 364    }
 365
 366    return uni;
 367 }
 368
 369 static void
 370 add_builtin_variable(exec_list *instructions, glsl_symbol_table *symtab,
 371                      const builtin_variable *proto)
 372 {
 373    /* Create a new variable declaration from the description supplied by
 374     * the caller.
 375     */
 376    const glsl_type *const type = symtab->get_type(proto->type);
 377
 378    assert(type != NULL);
 379
 380    if (proto->mode == ir_var_uniform) {
 381       add_uniform(instructions, symtab, proto->name, type);
 382    } else {
 383       add_variable(instructions, symtab, proto->name, type, proto->mode,
 384                    proto->slot);
 385    }
 386 }
 387
 388 static void
 389 add_builtin_constant(exec_list *instructions, glsl_symbol_table *symtab,
 390                      const char *name, int value)
 391 {
 392    ir_variable *const var = add_variable(instructions, symtab,
 393                                          name, glsl_type::int_type,
 394                                          ir_var_auto, -1);
 395    var->constant_value = new(var) ir_constant(value);
 396 }
 397
 398 /* Several constants in GLSL ES have different names than normal desktop GLSL.
 399  * Therefore, this function should only be called on the ES path.
 400  */
 401 static void
 402 generate_100ES_uniforms(exec_list *instructions,
 403                      struct _mesa_glsl_parse_state *state)
 404 {
 405    glsl_symbol_table *const symtab = state->symbols;
 406
 407    add_builtin_constant(instructions, symtab, "gl_MaxVertexAttribs",
 408                         state->Const.MaxVertexAttribs);
 409    add_builtin_constant(instructions, symtab, "gl_MaxVertexUniformVectors",
 410                         state->Const.MaxVertexUniformComponents);
 411    add_builtin_constant(instructions, symtab, "gl_MaxVaryingVectors",
 412                         state->Const.MaxVaryingFloats / 4);
 413    add_builtin_constant(instructions, symtab, "gl_MaxVertexTextureImageUnits",
 414                         state->Const.MaxVertexTextureImageUnits);
 415    add_builtin_constant(instructions, symtab, "gl_MaxCombinedTextureImageUnits",
 416                         state->Const.MaxCombinedTextureImageUnits);
 417    add_builtin_constant(instructions, symtab, "gl_MaxTextureImageUnits",
 418                         state->Const.MaxTextureImageUnits);
 419    add_builtin_constant(instructions, symtab, "gl_MaxFragmentUniformVectors",
 420                         state->Const.MaxFragmentUniformComponents);
 421
 422    add_uniform(instructions, symtab, "gl_DepthRange",
 423                state->symbols->get_type("gl_DepthRangeParameters"));
 424 }
 425
 426 static void
 427 generate_110_uniforms(exec_list *instructions,
 428                       struct _mesa_glsl_parse_state *state)
 429 {
 430    glsl_symbol_table *const symtab = state->symbols;
 431
 432    for (unsigned i = 0
 433            ; i < Elements(builtin_110_deprecated_uniforms)
 434            ; i++) {
 435       add_builtin_variable(instructions, symtab,
 436                            & builtin_110_deprecated_uniforms[i]);
 437    }
 438
 439    add_builtin_constant(instructions, symtab, "gl_MaxLights",
 440                         state->Const.MaxLights);
 441    add_builtin_constant(instructions, symtab, "gl_MaxClipPlanes",
 442                         state->Const.MaxClipPlanes);
 443    add_builtin_constant(instructions, symtab, "gl_MaxTextureUnits",
 444                         state->Const.MaxTextureUnits);
 445    add_builtin_constant(instructions, symtab, "gl_MaxTextureCoords",
 446                         state->Const.MaxTextureCoords);
 447    add_builtin_constant(instructions, symtab, "gl_MaxVertexAttribs",
 448                         state->Const.MaxVertexAttribs);
 449    add_builtin_constant(instructions, symtab, "gl_MaxVertexUniformComponents",
 450                         state->Const.MaxVertexUniformComponents);
 451    add_builtin_constant(instructions, symtab, "gl_MaxVaryingFloats",
 452                         state->Const.MaxVaryingFloats);
 453    add_builtin_constant(instructions, symtab, "gl_MaxVertexTextureImageUnits",
 454                         state->Const.MaxVertexTextureImageUnits);
 455    add_builtin_constant(instructions, symtab, "gl_MaxCombinedTextureImageUnits",
 456                         state->Const.MaxCombinedTextureImageUnits);
 457    add_builtin_constant(instructions, symtab, "gl_MaxTextureImageUnits",
 458                         state->Const.MaxTextureImageUnits);
 459    add_builtin_constant(instructions, symtab, "gl_MaxFragmentUniformComponents",
 460                         state->Const.MaxFragmentUniformComponents);
 461
 462    const glsl_type *const mat4_array_type =
 463       glsl_type::get_array_instance(glsl_type::mat4_type,
 464                                     state->Const.MaxTextureCoords);
 465
 466    add_uniform(instructions, symtab, "gl_TextureMatrix", mat4_array_type);
 467    add_uniform(instructions, symtab, "gl_TextureMatrixInverse", mat4_array_type);
 468    add_uniform(instructions, symtab, "gl_TextureMatrixTranspose", mat4_array_type);
 469    add_uniform(instructions, symtab, "gl_TextureMatrixInverseTranspose", mat4_array_type);
 470
 471    add_uniform(instructions, symtab, "gl_DepthRange",
 472                 symtab->get_type("gl_DepthRangeParameters"));
 473
 474    add_uniform(instructions, symtab, "gl_ClipPlane",
 475                glsl_type::get_array_instance(glsl_type::vec4_type,
 476                                              state->Const.MaxClipPlanes));
 477    add_uniform(instructions, symtab, "gl_Point",
 478                symtab->get_type("gl_PointParameters"));
 479
 480    const glsl_type *const material_parameters_type =
 481       symtab->get_type("gl_MaterialParameters");
 482    add_uniform(instructions, symtab, "gl_FrontMaterial", material_parameters_type);
 483    add_uniform(instructions, symtab, "gl_BackMaterial", material_parameters_type);
 484
 485    const glsl_type *const light_source_array_type =
 486       glsl_type::get_array_instance(symtab->get_type("gl_LightSourceParameters"), state->Const.MaxLights);
 487
 488    add_uniform(instructions, symtab, "gl_LightSource", light_source_array_type);
 489
 490    const glsl_type *const light_model_products_type =
 491       symtab->get_type("gl_LightModelProducts");
 492    add_uniform(instructions, symtab, "gl_FrontLightModelProduct",
 493                light_model_products_type);
 494    add_uniform(instructions, symtab, "gl_BackLightModelProduct",
 495                light_model_products_type);
 496
 497    const glsl_type *const light_products_type =
 498       glsl_type::get_array_instance(symtab->get_type("gl_LightProducts"),
 499                                     state->Const.MaxLights);
 500    add_uniform(instructions, symtab, "gl_FrontLightProduct", light_products_type);
 501    add_uniform(instructions, symtab, "gl_BackLightProduct", light_products_type);
 502
 503    add_uniform(instructions, symtab, "gl_TextureEnvColor",
 504                glsl_type::get_array_instance(glsl_type::vec4_type,
 505                                              state->Const.MaxTextureUnits));
 506
 507    const glsl_type *const texcoords_vec4 =
 508       glsl_type::get_array_instance(glsl_type::vec4_type,
 509                                     state->Const.MaxTextureCoords);
 510    add_uniform(instructions, symtab, "gl_EyePlaneS", texcoords_vec4);
 511    add_uniform(instructions, symtab, "gl_EyePlaneT", texcoords_vec4);
 512    add_uniform(instructions, symtab, "gl_EyePlaneR", texcoords_vec4);
 513    add_uniform(instructions, symtab, "gl_EyePlaneQ", texcoords_vec4);
 514    add_uniform(instructions, symtab, "gl_ObjectPlaneS", texcoords_vec4);
 515    add_uniform(instructions, symtab, "gl_ObjectPlaneT", texcoords_vec4);
 516    add_uniform(instructions, symtab, "gl_ObjectPlaneR", texcoords_vec4);
 517    add_uniform(instructions, symtab, "gl_ObjectPlaneQ", texcoords_vec4);
 518
 519    add_uniform(instructions, symtab, "gl_Fog",
 520                symtab->get_type("gl_FogParameters"));
 521 }
 522
 523 /* This function should only be called for ES, not desktop GL. */
 524 static void
 525 generate_100ES_vs_variables(exec_list *instructions,
 526                           struct _mesa_glsl_parse_state *state)
 527 {
 528    for (unsigned i = 0; i < Elements(builtin_core_vs_variables); i++) {
 529       add_builtin_variable(instructions, state->symbols,
 530                            & builtin_core_vs_variables[i]);
 531    }
 532
 533    generate_100ES_uniforms(instructions, state);
 534
 535    generate_ARB_draw_buffers_variables(instructions, state, false,
 536                                        vertex_shader);
 537 }
 538
 539
 540 static void
 541 generate_110_vs_variables(exec_list *instructions,
 542                           struct _mesa_glsl_parse_state *state)
 543 {
 544    for (unsigned i = 0; i < Elements(builtin_core_vs_variables); i++) {
 545       add_builtin_variable(instructions, state->symbols,
 546                            & builtin_core_vs_variables[i]);
 547    }
 548
 549    for (unsigned i = 0
 550            ; i < Elements(builtin_110_deprecated_vs_variables)
 551            ; i++) {
 552       add_builtin_variable(instructions, state->symbols,
 553                            & builtin_110_deprecated_vs_variables[i]);
 554    }
 555    generate_110_uniforms(instructions, state);
 556
 557    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
 558     *
 559     *     "As with all arrays, indices used to subscript gl_TexCoord must
 560     *     either be an integral constant expressions, or this array must be
 561     *     re-declared by the shader with a size. The size can be at most
 562     *     gl_MaxTextureCoords. Using indexes close to 0 may aid the
 563     *     implementation in preserving varying resources."
 564     */
 565    const glsl_type *const vec4_array_type =
 566       glsl_type::get_array_instance(glsl_type::vec4_type, 0);
 567
 568    add_variable(instructions, state->symbols,
 569                 "gl_TexCoord", vec4_array_type, ir_var_out, VERT_RESULT_TEX0);
 570
 571    generate_ARB_draw_buffers_variables(instructions, state, false,
 572                                        vertex_shader);
 573 }
 574
 575
 576 static void
 577 generate_120_vs_variables(exec_list *instructions,
 578                           struct _mesa_glsl_parse_state *state)
 579 {
 580    /* GLSL version 1.20 did not add any built-in variables in the vertex
 581     * shader.
 582     */
 583    generate_110_vs_variables(instructions, state);
 584 }
 585
 586
 587 static void
 588 generate_130_vs_variables(exec_list *instructions,
 589                           struct _mesa_glsl_parse_state *state)
 590 {
 591    generate_120_vs_variables(instructions, state);
 592
 593    for (unsigned i = 0; i < Elements(builtin_130_vs_variables); i++) {
 594       add_builtin_variable(instructions, state->symbols,
 595                            & builtin_130_vs_variables[i]);
 596    }
 597
 598    /* From the GLSL 1.30 spec, section 7.1 (Vertex Shader Special
 599     * Variables):
 600     *
 601     *   The gl_ClipDistance array is predeclared as unsized and must
 602     *   be sized by the shader either redeclaring it with a size or
 603     *   indexing it only with integral constant expressions.
 604     *
 605     * We represent this in Mesa by initially declaring the array as
 606     * size 0.
 607     */
 608    const glsl_type *const clip_distance_array_type =
 609       glsl_type::get_array_instance(glsl_type::float_type, 0);
 610
 611    /* FINISHME: gl_ClipDistance needs a real location assigned. */
 612    add_variable(instructions, state->symbols,
 613                 "gl_ClipDistance", clip_distance_array_type, ir_var_out, -1);
 614
 615 }
 616
 617
 618 static void
 619 initialize_vs_variables(exec_list *instructions,
 620                         struct _mesa_glsl_parse_state *state)
 621 {
 622
 623    switch (state->language_version) {
 624    case 100:
 625       generate_100ES_vs_variables(instructions, state);
 626       break;
 627    case 110:
 628       generate_110_vs_variables(instructions, state);
 629       break;
 630    case 120:
 631       generate_120_vs_variables(instructions, state);
 632       break;
 633    case 130:
 634       generate_130_vs_variables(instructions, state);
 635       break;
 636    }
 637
 638    if (state->ARB_draw_instanced_enable)
 639       generate_ARB_draw_instanced_variables(instructions, state, false,
 640                                             vertex_shader);
 641 }
 642
 643
 644 /* This function should only be called for ES, not desktop GL. */
 645 static void
 646 generate_100ES_fs_variables(exec_list *instructions,
 647                           struct _mesa_glsl_parse_state *state)
 648 {
 649    for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
 650       add_builtin_variable(instructions, state->symbols,
 651                            & builtin_core_fs_variables[i]);
 652    }
 653
 654    for (unsigned i = 0; i < Elements(builtin_100ES_fs_variables); i++) {
 655       add_builtin_variable(instructions, state->symbols,
 656                            & builtin_100ES_fs_variables[i]);
 657    }
 658
 659    generate_100ES_uniforms(instructions, state);
 660
 661    generate_ARB_draw_buffers_variables(instructions, state, false,
 662                                        fragment_shader);
 663 }
 664
 665 static void
 666 generate_110_fs_variables(exec_list *instructions,
 667                           struct _mesa_glsl_parse_state *state)
 668 {
 669    for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
 670       add_builtin_variable(instructions, state->symbols,
 671                            & builtin_core_fs_variables[i]);
 672    }
 673
 674    for (unsigned i = 0; i < Elements(builtin_110_fs_variables); i++) {
 675       add_builtin_variable(instructions, state->symbols,
 676                            & builtin_110_fs_variables[i]);
 677    }
 678
 679    for (unsigned i = 0
 680            ; i < Elements(builtin_110_deprecated_fs_variables)
 681            ; i++) {
 682       add_builtin_variable(instructions, state->symbols,
 683                            & builtin_110_deprecated_fs_variables[i]);
 684    }
 685    generate_110_uniforms(instructions, state);
 686
 687    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
 688     *
 689     *     "As with all arrays, indices used to subscript gl_TexCoord must
 690     *     either be an integral constant expressions, or this array must be
 691     *     re-declared by the shader with a size. The size can be at most
 692     *     gl_MaxTextureCoords. Using indexes close to 0 may aid the
 693     *     implementation in preserving varying resources."
 694     */
 695    const glsl_type *const vec4_array_type =
 696       glsl_type::get_array_instance(glsl_type::vec4_type, 0);
 697
 698    add_variable(instructions, state->symbols,
 699                 "gl_TexCoord", vec4_array_type, ir_var_in, FRAG_ATTRIB_TEX0);
 700
 701    generate_ARB_draw_buffers_variables(instructions, state, false,
 702                                        fragment_shader);
 703 }
 704
 705
 706 static void
 707 generate_ARB_draw_buffers_variables(exec_list *instructions,
 708                                     struct _mesa_glsl_parse_state *state,
 709                                     bool warn, _mesa_glsl_parser_targets target)
 710 {
 711    /* gl_MaxDrawBuffers is available in all shader stages.
 712     */
 713    ir_variable *const mdb =
 714       add_variable(instructions, state->symbols,
 715                    "gl_MaxDrawBuffers", glsl_type::int_type, ir_var_auto, -1);
 716
 717    if (warn)
 718       mdb->warn_extension = "GL_ARB_draw_buffers";
 719
 720    mdb->constant_value = new(mdb)
 721       ir_constant(int(state->Const.MaxDrawBuffers));
 722
 723
 724    /* gl_FragData is only available in the fragment shader.
 725     */
 726    if (target == fragment_shader) {
 727       const glsl_type *const vec4_array_type =
 728          glsl_type::get_array_instance(glsl_type::vec4_type,
 729                                        state->Const.MaxDrawBuffers);
 730
 731       ir_variable *const fd =
 732          add_variable(instructions, state->symbols,
 733                       "gl_FragData", vec4_array_type,
 734                       ir_var_out, FRAG_RESULT_DATA0);
 735
 736       if (warn)
 737          fd->warn_extension = "GL_ARB_draw_buffers";
 738    }
 739 }
 740
 741
 742 static void
 743 generate_ARB_draw_instanced_variables(exec_list *instructions,
 744                                       struct _mesa_glsl_parse_state *state,
 745                                       bool warn,
 746                                       _mesa_glsl_parser_targets target)
 747 {
 748    /* gl_InstanceIDARB is only available in the vertex shader.
 749     */
 750    if (target == vertex_shader) {
 751       ir_variable *const inst =
 752          add_variable(instructions, state->symbols,
 753                       "gl_InstanceIDARB", glsl_type::int_type,
 754                       ir_var_system_value, SYSTEM_VALUE_INSTANCE_ID);
 755
 756       if (warn)
 757          inst->warn_extension = "GL_ARB_draw_instanced";
 758    }
 759 }
 760
 761
 762 static void
 763 generate_ARB_shader_stencil_export_variables(exec_list *instructions,
 764                                              struct _mesa_glsl_parse_state *state,
 765                                              bool warn)
 766 {
 767    /* gl_FragStencilRefARB is only available in the fragment shader.
 768     */
 769    ir_variable *const fd =
 770       add_variable(instructions, state->symbols,
 771                    "gl_FragStencilRefARB", glsl_type::int_type,
 772                    ir_var_out, FRAG_RESULT_STENCIL);
 773
 774    if (warn)
 775       fd->warn_extension = "GL_ARB_shader_stencil_export";
 776 }
 777
 778 static void
 779 generate_AMD_shader_stencil_export_variables(exec_list *instructions,
 780                                              struct _mesa_glsl_parse_state *state,
 781                                              bool warn)
 782 {
 783    /* gl_FragStencilRefAMD is only available in the fragment shader.
 784     */
 785    ir_variable *const fd =
 786       add_variable(instructions, state->symbols,
 787                    "gl_FragStencilRefAMD", glsl_type::int_type,
 788                    ir_var_out, FRAG_RESULT_STENCIL);
 789
 790    if (warn)
 791       fd->warn_extension = "GL_AMD_shader_stencil_export";
 792 }
 793
 794 static void
 795 generate_120_fs_variables(exec_list *instructions,
 796                           struct _mesa_glsl_parse_state *state)
 797 {
 798    generate_110_fs_variables(instructions, state);
 799
 800    for (unsigned i = 0
 801            ; i < Elements(builtin_120_fs_variables)
 802            ; i++) {
 803       add_builtin_variable(instructions, state->symbols,
 804                            & builtin_120_fs_variables[i]);
 805    }
 806 }
 807
 808 static void
 809 generate_130_fs_variables(exec_list *instructions,
 810                           struct _mesa_glsl_parse_state *state)
 811 {
 812    generate_120_fs_variables(instructions, state);
 813
 814    /* From the GLSL 1.30 spec, section 7.2 (Fragment Shader Special
 815     * Variables):
 816     *
 817     *   The built-in input variable gl_ClipDistance array contains linearly
 818     *   interpolated values for the vertex values written by the vertex shader
 819     *   to the gl_ClipDistance vertex output variable. This array must be
 820     *   sized in the fragment shader either implicitly or explicitly to be the
 821     *   same size as it was sized in the vertex shader.
 822     *
 823     * In other words, the array must be pre-declared as implicitly sized.  We
 824     * represent this in Mesa by initially declaring the array as size 0.
 825     */
 826    const glsl_type *const clip_distance_array_type =
 827       glsl_type::get_array_instance(glsl_type::float_type, 0);
 828
 829    /* FINISHME: gl_ClipDistance needs a real location assigned. */
 830    add_variable(instructions, state->symbols,
 831                 "gl_ClipDistance", clip_distance_array_type, ir_var_in, -1);
 832 }
 833
 834 static void
 835 initialize_fs_variables(exec_list *instructions,
 836                         struct _mesa_glsl_parse_state *state)
 837 {
 838
 839    switch (state->language_version) {
 840    case 100:
 841       generate_100ES_fs_variables(instructions, state);
 842       break;
 843    case 110:
 844       generate_110_fs_variables(instructions, state);
 845       break;
 846    case 120:
 847       generate_120_fs_variables(instructions, state);
 848       break;
 849    case 130:
 850       generate_130_fs_variables(instructions, state);
 851       break;
 852    }
 853
 854    if (state->ARB_shader_stencil_export_enable)
 855       generate_ARB_shader_stencil_export_variables(instructions, state,
 856                                                    state->ARB_shader_stencil_export_warn);
 857
 858    if (state->AMD_shader_stencil_export_enable)
 859       generate_AMD_shader_stencil_export_variables(instructions, state,
 860                                                    state->AMD_shader_stencil_export_warn);
 861 }
 862
 863 void
 864 _mesa_glsl_initialize_variables(exec_list *instructions,
 865                                 struct _mesa_glsl_parse_state *state)
 866 {
 867    switch (state->target) {
 868    case vertex_shader:
 869       initialize_vs_variables(instructions, state);
 870       break;
 871    case geometry_shader:
 872       break;
 873    case fragment_shader:
 874       initialize_fs_variables(instructions, state);
 875       break;
 876    }
 877 }