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_uniforms(exec_list *instructions,
 589                       struct _mesa_glsl_parse_state *state)
 590 {
 591    glsl_symbol_table *const symtab = state->symbols;
 592
 593    add_builtin_constant(instructions, symtab, "gl_MaxClipDistances",
 594                         state->Const.MaxClipPlanes);
 595 }
 596
 597
 598 static void
 599 generate_130_vs_variables(exec_list *instructions,
 600                           struct _mesa_glsl_parse_state *state)
 601 {
 602    generate_120_vs_variables(instructions, state);
 603
 604    for (unsigned i = 0; i < Elements(builtin_130_vs_variables); i++) {
 605       add_builtin_variable(instructions, state->symbols,
 606                            & builtin_130_vs_variables[i]);
 607    }
 608
 609    generate_130_uniforms(instructions, state);
 610
 611    /* From the GLSL 1.30 spec, section 7.1 (Vertex Shader Special
 612     * Variables):
 613     *
 614     *   The gl_ClipDistance array is predeclared as unsized and must
 615     *   be sized by the shader either redeclaring it with a size or
 616     *   indexing it only with integral constant expressions.
 617     *
 618     * We represent this in Mesa by initially declaring the array as
 619     * size 0.
 620     */
 621    const glsl_type *const clip_distance_array_type =
 622       glsl_type::get_array_instance(glsl_type::float_type, 0);
 623
 624    /* FINISHME: gl_ClipDistance needs a real location assigned. */
 625    add_variable(instructions, state->symbols,
 626                 "gl_ClipDistance", clip_distance_array_type, ir_var_out, -1);
 627
 628 }
 629
 630
 631 static void
 632 initialize_vs_variables(exec_list *instructions,
 633                         struct _mesa_glsl_parse_state *state)
 634 {
 635
 636    switch (state->language_version) {
 637    case 100:
 638       generate_100ES_vs_variables(instructions, state);
 639       break;
 640    case 110:
 641       generate_110_vs_variables(instructions, state);
 642       break;
 643    case 120:
 644       generate_120_vs_variables(instructions, state);
 645       break;
 646    case 130:
 647       generate_130_vs_variables(instructions, state);
 648       break;
 649    }
 650
 651    if (state->ARB_draw_instanced_enable)
 652       generate_ARB_draw_instanced_variables(instructions, state, false,
 653                                             vertex_shader);
 654 }
 655
 656
 657 /* This function should only be called for ES, not desktop GL. */
 658 static void
 659 generate_100ES_fs_variables(exec_list *instructions,
 660                           struct _mesa_glsl_parse_state *state)
 661 {
 662    for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
 663       add_builtin_variable(instructions, state->symbols,
 664                            & builtin_core_fs_variables[i]);
 665    }
 666
 667    for (unsigned i = 0; i < Elements(builtin_100ES_fs_variables); i++) {
 668       add_builtin_variable(instructions, state->symbols,
 669                            & builtin_100ES_fs_variables[i]);
 670    }
 671
 672    generate_100ES_uniforms(instructions, state);
 673
 674    generate_ARB_draw_buffers_variables(instructions, state, false,
 675                                        fragment_shader);
 676 }
 677
 678 static void
 679 generate_110_fs_variables(exec_list *instructions,
 680                           struct _mesa_glsl_parse_state *state)
 681 {
 682    for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
 683       add_builtin_variable(instructions, state->symbols,
 684                            & builtin_core_fs_variables[i]);
 685    }
 686
 687    for (unsigned i = 0; i < Elements(builtin_110_fs_variables); i++) {
 688       add_builtin_variable(instructions, state->symbols,
 689                            & builtin_110_fs_variables[i]);
 690    }
 691
 692    for (unsigned i = 0
 693            ; i < Elements(builtin_110_deprecated_fs_variables)
 694            ; i++) {
 695       add_builtin_variable(instructions, state->symbols,
 696                            & builtin_110_deprecated_fs_variables[i]);
 697    }
 698    generate_110_uniforms(instructions, state);
 699
 700    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
 701     *
 702     *     "As with all arrays, indices used to subscript gl_TexCoord must
 703     *     either be an integral constant expressions, or this array must be
 704     *     re-declared by the shader with a size. The size can be at most
 705     *     gl_MaxTextureCoords. Using indexes close to 0 may aid the
 706     *     implementation in preserving varying resources."
 707     */
 708    const glsl_type *const vec4_array_type =
 709       glsl_type::get_array_instance(glsl_type::vec4_type, 0);
 710
 711    add_variable(instructions, state->symbols,
 712                 "gl_TexCoord", vec4_array_type, ir_var_in, FRAG_ATTRIB_TEX0);
 713
 714    generate_ARB_draw_buffers_variables(instructions, state, false,
 715                                        fragment_shader);
 716 }
 717
 718
 719 static void
 720 generate_ARB_draw_buffers_variables(exec_list *instructions,
 721                                     struct _mesa_glsl_parse_state *state,
 722                                     bool warn, _mesa_glsl_parser_targets target)
 723 {
 724    /* gl_MaxDrawBuffers is available in all shader stages.
 725     */
 726    ir_variable *const mdb =
 727       add_variable(instructions, state->symbols,
 728                    "gl_MaxDrawBuffers", glsl_type::int_type, ir_var_auto, -1);
 729
 730    if (warn)
 731       mdb->warn_extension = "GL_ARB_draw_buffers";
 732
 733    mdb->constant_value = new(mdb)
 734       ir_constant(int(state->Const.MaxDrawBuffers));
 735
 736
 737    /* gl_FragData is only available in the fragment shader.
 738     */
 739    if (target == fragment_shader) {
 740       const glsl_type *const vec4_array_type =
 741          glsl_type::get_array_instance(glsl_type::vec4_type,
 742                                        state->Const.MaxDrawBuffers);
 743
 744       ir_variable *const fd =
 745          add_variable(instructions, state->symbols,
 746                       "gl_FragData", vec4_array_type,
 747                       ir_var_out, FRAG_RESULT_DATA0);
 748
 749       if (warn)
 750          fd->warn_extension = "GL_ARB_draw_buffers";
 751    }
 752 }
 753
 754
 755 static void
 756 generate_ARB_draw_instanced_variables(exec_list *instructions,
 757                                       struct _mesa_glsl_parse_state *state,
 758                                       bool warn,
 759                                       _mesa_glsl_parser_targets target)
 760 {
 761    /* gl_InstanceIDARB is only available in the vertex shader.
 762     */
 763    if (target == vertex_shader) {
 764       ir_variable *const inst =
 765          add_variable(instructions, state->symbols,
 766                       "gl_InstanceIDARB", glsl_type::int_type,
 767                       ir_var_system_value, SYSTEM_VALUE_INSTANCE_ID);
 768
 769       if (warn)
 770          inst->warn_extension = "GL_ARB_draw_instanced";
 771    }
 772 }
 773
 774
 775 static void
 776 generate_ARB_shader_stencil_export_variables(exec_list *instructions,
 777                                              struct _mesa_glsl_parse_state *state,
 778                                              bool warn)
 779 {
 780    /* gl_FragStencilRefARB is only available in the fragment shader.
 781     */
 782    ir_variable *const fd =
 783       add_variable(instructions, state->symbols,
 784                    "gl_FragStencilRefARB", glsl_type::int_type,
 785                    ir_var_out, FRAG_RESULT_STENCIL);
 786
 787    if (warn)
 788       fd->warn_extension = "GL_ARB_shader_stencil_export";
 789 }
 790
 791 static void
 792 generate_AMD_shader_stencil_export_variables(exec_list *instructions,
 793                                              struct _mesa_glsl_parse_state *state,
 794                                              bool warn)
 795 {
 796    /* gl_FragStencilRefAMD is only available in the fragment shader.
 797     */
 798    ir_variable *const fd =
 799       add_variable(instructions, state->symbols,
 800                    "gl_FragStencilRefAMD", glsl_type::int_type,
 801                    ir_var_out, FRAG_RESULT_STENCIL);
 802
 803    if (warn)
 804       fd->warn_extension = "GL_AMD_shader_stencil_export";
 805 }
 806
 807 static void
 808 generate_120_fs_variables(exec_list *instructions,
 809                           struct _mesa_glsl_parse_state *state)
 810 {
 811    generate_110_fs_variables(instructions, state);
 812
 813    for (unsigned i = 0
 814            ; i < Elements(builtin_120_fs_variables)
 815            ; i++) {
 816       add_builtin_variable(instructions, state->symbols,
 817                            & builtin_120_fs_variables[i]);
 818    }
 819 }
 820
 821 static void
 822 generate_130_fs_variables(exec_list *instructions,
 823                           struct _mesa_glsl_parse_state *state)
 824 {
 825    generate_120_fs_variables(instructions, state);
 826
 827    generate_130_uniforms(instructions, state);
 828
 829    /* From the GLSL 1.30 spec, section 7.2 (Fragment Shader Special
 830     * Variables):
 831     *
 832     *   The built-in input variable gl_ClipDistance array contains linearly
 833     *   interpolated values for the vertex values written by the vertex shader
 834     *   to the gl_ClipDistance vertex output variable. This array must be
 835     *   sized in the fragment shader either implicitly or explicitly to be the
 836     *   same size as it was sized in the vertex shader.
 837     *
 838     * In other words, the array must be pre-declared as implicitly sized.  We
 839     * represent this in Mesa by initially declaring the array as size 0.
 840     */
 841    const glsl_type *const clip_distance_array_type =
 842       glsl_type::get_array_instance(glsl_type::float_type, 0);
 843
 844    /* FINISHME: gl_ClipDistance needs a real location assigned. */
 845    add_variable(instructions, state->symbols,
 846                 "gl_ClipDistance", clip_distance_array_type, ir_var_in, -1);
 847 }
 848
 849 static void
 850 initialize_fs_variables(exec_list *instructions,
 851                         struct _mesa_glsl_parse_state *state)
 852 {
 853
 854    switch (state->language_version) {
 855    case 100:
 856       generate_100ES_fs_variables(instructions, state);
 857       break;
 858    case 110:
 859       generate_110_fs_variables(instructions, state);
 860       break;
 861    case 120:
 862       generate_120_fs_variables(instructions, state);
 863       break;
 864    case 130:
 865       generate_130_fs_variables(instructions, state);
 866       break;
 867    }
 868
 869    if (state->ARB_shader_stencil_export_enable)
 870       generate_ARB_shader_stencil_export_variables(instructions, state,
 871                                                    state->ARB_shader_stencil_export_warn);
 872
 873    if (state->AMD_shader_stencil_export_enable)
 874       generate_AMD_shader_stencil_export_variables(instructions, state,
 875                                                    state->AMD_shader_stencil_export_warn);
 876 }
 877
 878 void
 879 _mesa_glsl_initialize_variables(exec_list *instructions,
 880                                 struct _mesa_glsl_parse_state *state)
 881 {
 882    switch (state->target) {
 883    case vertex_shader:
 884       initialize_vs_variables(instructions, state);
 885       break;
 886    case geometry_shader:
 887       break;
 888    case fragment_shader:
 889       initialize_fs_variables(instructions, state);
 890       break;
 891    }
 892 }