src/glsl/builtin_variables.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 "main/core.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 struct builtin_variable {
  43    enum ir_variable_mode mode;
  44    int slot;
  45    const char *type;
  46    const char *name;
  47 };
  48
  49 static const builtin_variable builtin_core_vs_variables[] = {
  50    { ir_var_out, VERT_RESULT_HPOS, "vec4",  "gl_Position" },
  51    { ir_var_out, VERT_RESULT_PSIZ, "float", "gl_PointSize" },
  52 };
  53
  54 static const builtin_variable builtin_core_fs_variables[] = {
  55    { ir_var_in,  FRAG_ATTRIB_WPOS,  "vec4",  "gl_FragCoord" },
  56    { ir_var_in,  FRAG_ATTRIB_FACE,  "bool",  "gl_FrontFacing" },
  57    { ir_var_out, FRAG_RESULT_COLOR, "vec4",  "gl_FragColor" },
  58 };
  59
  60 static const builtin_variable builtin_100ES_fs_variables[] = {
  61    { ir_var_in,  FRAG_ATTRIB_PNTC,   "vec2",   "gl_PointCoord" },
  62 };
  63
  64 static const builtin_variable builtin_110_fs_variables[] = {
  65    { ir_var_out, FRAG_RESULT_DEPTH, "float", "gl_FragDepth" },
  66 };
  67
  68 static const builtin_variable builtin_110_deprecated_fs_variables[] = {
  69    { ir_var_in,  FRAG_ATTRIB_COL0,  "vec4",  "gl_Color" },
  70    { ir_var_in,  FRAG_ATTRIB_COL1,  "vec4",  "gl_SecondaryColor" },
  71    { ir_var_in,  FRAG_ATTRIB_FOGC,  "float", "gl_FogFragCoord" },
  72 };
  73
  74 static const builtin_variable builtin_110_deprecated_vs_variables[] = {
  75    { ir_var_in,  VERT_ATTRIB_POS,         "vec4",  "gl_Vertex" },
  76    { ir_var_in,  VERT_ATTRIB_NORMAL,      "vec3",  "gl_Normal" },
  77    { ir_var_in,  VERT_ATTRIB_COLOR0,      "vec4",  "gl_Color" },
  78    { ir_var_in,  VERT_ATTRIB_COLOR1,      "vec4",  "gl_SecondaryColor" },
  79    { ir_var_in,  VERT_ATTRIB_TEX0,        "vec4",  "gl_MultiTexCoord0" },
  80    { ir_var_in,  VERT_ATTRIB_TEX1,        "vec4",  "gl_MultiTexCoord1" },
  81    { ir_var_in,  VERT_ATTRIB_TEX2,        "vec4",  "gl_MultiTexCoord2" },
  82    { ir_var_in,  VERT_ATTRIB_TEX3,        "vec4",  "gl_MultiTexCoord3" },
  83    { ir_var_in,  VERT_ATTRIB_TEX4,        "vec4",  "gl_MultiTexCoord4" },
  84    { ir_var_in,  VERT_ATTRIB_TEX5,        "vec4",  "gl_MultiTexCoord5" },
  85    { ir_var_in,  VERT_ATTRIB_TEX6,        "vec4",  "gl_MultiTexCoord6" },
  86    { ir_var_in,  VERT_ATTRIB_TEX7,        "vec4",  "gl_MultiTexCoord7" },
  87    { ir_var_in,  VERT_ATTRIB_FOG,         "float", "gl_FogCoord" },
  88    { ir_var_out, VERT_RESULT_CLIP_VERTEX, "vec4",  "gl_ClipVertex" },
  89    { ir_var_out, VERT_RESULT_COL0,        "vec4",  "gl_FrontColor" },
  90    { ir_var_out, VERT_RESULT_BFC0,        "vec4",  "gl_BackColor" },
  91    { ir_var_out, VERT_RESULT_COL1,        "vec4",  "gl_FrontSecondaryColor" },
  92    { ir_var_out, VERT_RESULT_BFC1,        "vec4",  "gl_BackSecondaryColor" },
  93    { ir_var_out, VERT_RESULT_FOGC,        "float", "gl_FogFragCoord" },
  94 };
  95
  96 static const builtin_variable builtin_120_fs_variables[] = {
  97    { ir_var_in,  FRAG_ATTRIB_PNTC,   "vec2",   "gl_PointCoord" },
  98 };
  99
 100 static const builtin_variable builtin_130_vs_variables[] = {
 101    { ir_var_system_value,  SYSTEM_VALUE_VERTEX_ID, "int",   "gl_VertexID" },
 102 };
 103
 104 static const builtin_variable builtin_110_deprecated_uniforms[] = {
 105    { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrix" },
 106    { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrix" },
 107    { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrix" },
 108    { ir_var_uniform, -1, "mat3", "gl_NormalMatrix" },
 109    { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixInverse" },
 110    { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixInverse" },
 111    { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixInverse" },
 112    { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixTranspose" },
 113    { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixTranspose" },
 114    { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixTranspose" },
 115    { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixInverseTranspose" },
 116    { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixInverseTranspose" },
 117    { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixInverseTranspose" },
 118    { ir_var_uniform, -1, "float", "gl_NormalScale" },
 119    { ir_var_uniform, -1, "gl_LightModelParameters", "gl_LightModel"},
 120
 121    /* Mesa-internal ATI_envmap_bumpmap state. */
 122    { ir_var_uniform, -1, "vec2", "gl_BumpRotMatrix0MESA"},
 123    { ir_var_uniform, -1, "vec2", "gl_BumpRotMatrix1MESA"},
 124    { ir_var_uniform, -1, "vec4", "gl_FogParamsOptimizedMESA"},
 125 };
 126
 127 static struct gl_builtin_uniform_element gl_DepthRange_elements[] = {
 128    {"near", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_XXXX},
 129    {"far", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_YYYY},
 130    {"diff", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_ZZZZ},
 131 };
 132
 133 static struct gl_builtin_uniform_element gl_ClipPlane_elements[] = {
 134    {NULL, {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW}
 135 };
 136
 137 static struct gl_builtin_uniform_element gl_Point_elements[] = {
 138    {"size", {STATE_POINT_SIZE}, SWIZZLE_XXXX},
 139    {"sizeMin", {STATE_POINT_SIZE}, SWIZZLE_YYYY},
 140    {"sizeMax", {STATE_POINT_SIZE}, SWIZZLE_ZZZZ},
 141    {"fadeThresholdSize", {STATE_POINT_SIZE}, SWIZZLE_WWWW},
 142    {"distanceConstantAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_XXXX},
 143    {"distanceLinearAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_YYYY},
 144    {"distanceQuadraticAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_ZZZZ},
 145 };
 146
 147 static struct gl_builtin_uniform_element gl_FrontMaterial_elements[] = {
 148    {"emission", {STATE_MATERIAL, 0, STATE_EMISSION}, SWIZZLE_XYZW},
 149    {"ambient", {STATE_MATERIAL, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
 150    {"diffuse", {STATE_MATERIAL, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
 151    {"specular", {STATE_MATERIAL, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
 152    {"shininess", {STATE_MATERIAL, 0, STATE_SHININESS}, SWIZZLE_XXXX},
 153 };
 154
 155 static struct gl_builtin_uniform_element gl_BackMaterial_elements[] = {
 156    {"emission", {STATE_MATERIAL, 1, STATE_EMISSION}, SWIZZLE_XYZW},
 157    {"ambient", {STATE_MATERIAL, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
 158    {"diffuse", {STATE_MATERIAL, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
 159    {"specular", {STATE_MATERIAL, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
 160    {"shininess", {STATE_MATERIAL, 1, STATE_SHININESS}, SWIZZLE_XXXX},
 161 };
 162
 163 static struct gl_builtin_uniform_element gl_LightSource_elements[] = {
 164    {"ambient", {STATE_LIGHT, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
 165    {"diffuse", {STATE_LIGHT, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
 166    {"specular", {STATE_LIGHT, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
 167    {"position", {STATE_LIGHT, 0, STATE_POSITION}, SWIZZLE_XYZW},
 168    {"halfVector", {STATE_LIGHT, 0, STATE_HALF_VECTOR}, SWIZZLE_XYZW},
 169    {"spotDirection", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION},
 170     MAKE_SWIZZLE4(SWIZZLE_X,
 171                   SWIZZLE_Y,
 172                   SWIZZLE_Z,
 173                   SWIZZLE_Z)},
 174    {"spotCosCutoff", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_WWWW},
 175    {"spotCutoff", {STATE_LIGHT, 0, STATE_SPOT_CUTOFF}, SWIZZLE_XXXX},
 176    {"spotExponent", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_WWWW},
 177    {"constantAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_XXXX},
 178    {"linearAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_YYYY},
 179    {"quadraticAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_ZZZZ},
 180 };
 181
 182 static struct gl_builtin_uniform_element gl_LightModel_elements[] = {
 183    {"ambient", {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW},
 184 };
 185
 186 static struct gl_builtin_uniform_element gl_FrontLightModelProduct_elements[] = {
 187    {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW},
 188 };
 189
 190 static struct gl_builtin_uniform_element gl_BackLightModelProduct_elements[] = {
 191    {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW},
 192 };
 193
 194 static struct gl_builtin_uniform_element gl_FrontLightProduct_elements[] = {
 195    {"ambient", {STATE_LIGHTPROD, 0, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
 196    {"diffuse", {STATE_LIGHTPROD, 0, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
 197    {"specular", {STATE_LIGHTPROD, 0, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
 198 };
 199
 200 static struct gl_builtin_uniform_element gl_BackLightProduct_elements[] = {
 201    {"ambient", {STATE_LIGHTPROD, 0, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
 202    {"diffuse", {STATE_LIGHTPROD, 0, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
 203    {"specular", {STATE_LIGHTPROD, 0, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
 204 };
 205
 206 static struct gl_builtin_uniform_element gl_TextureEnvColor_elements[] = {
 207    {NULL, {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW},
 208 };
 209
 210 static struct gl_builtin_uniform_element gl_EyePlaneS_elements[] = {
 211    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW},
 212 };
 213
 214 static struct gl_builtin_uniform_element gl_EyePlaneT_elements[] = {
 215    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW},
 216 };
 217
 218 static struct gl_builtin_uniform_element gl_EyePlaneR_elements[] = {
 219    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW},
 220 };
 221
 222 static struct gl_builtin_uniform_element gl_EyePlaneQ_elements[] = {
 223    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW},
 224 };
 225
 226 static struct gl_builtin_uniform_element gl_ObjectPlaneS_elements[] = {
 227    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW},
 228 };
 229
 230 static struct gl_builtin_uniform_element gl_ObjectPlaneT_elements[] = {
 231    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW},
 232 };
 233
 234 static struct gl_builtin_uniform_element gl_ObjectPlaneR_elements[] = {
 235    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW},
 236 };
 237
 238 static struct gl_builtin_uniform_element gl_ObjectPlaneQ_elements[] = {
 239    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW},
 240 };
 241
 242 static struct gl_builtin_uniform_element gl_Fog_elements[] = {
 243    {"color", {STATE_FOG_COLOR}, SWIZZLE_XYZW},
 244    {"density", {STATE_FOG_PARAMS}, SWIZZLE_XXXX},
 245    {"start", {STATE_FOG_PARAMS}, SWIZZLE_YYYY},
 246    {"end", {STATE_FOG_PARAMS}, SWIZZLE_ZZZZ},
 247    {"scale", {STATE_FOG_PARAMS}, SWIZZLE_WWWW},
 248 };
 249
 250 static struct gl_builtin_uniform_element gl_NormalScale_elements[] = {
 251    {NULL, {STATE_NORMAL_SCALE}, SWIZZLE_XXXX},
 252 };
 253
 254 static struct gl_builtin_uniform_element gl_BumpRotMatrix0MESA_elements[] = {
 255    {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_0}, SWIZZLE_XYZW},
 256 };
 257
 258 static struct gl_builtin_uniform_element gl_BumpRotMatrix1MESA_elements[] = {
 259    {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_1}, SWIZZLE_XYZW},
 260 };
 261
 262 static struct gl_builtin_uniform_element gl_FogParamsOptimizedMESA_elements[] = {
 263    {NULL, {STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED}, SWIZZLE_XYZW},
 264 };
 265
 266 static struct gl_builtin_uniform_element gl_CurrentAttribVertMESA_elements[] = {
 267    {NULL, {STATE_INTERNAL, STATE_CURRENT_ATTRIB, 0}, SWIZZLE_XYZW},
 268 };
 269
 270 static struct gl_builtin_uniform_element gl_CurrentAttribFragMESA_elements[] = {
 271    {NULL, {STATE_INTERNAL, STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED, 0}, SWIZZLE_XYZW},
 272 };
 273
 274 #define MATRIX(name, statevar, modifier)                                \
 275    static struct gl_builtin_uniform_element name ## _elements[] = {     \
 276       { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW },           \
 277       { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW },           \
 278       { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW },           \
 279       { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW },           \
 280    }
 281
 282 MATRIX(gl_ModelViewMatrix,
 283        STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE);
 284 MATRIX(gl_ModelViewMatrixInverse,
 285        STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS);
 286 MATRIX(gl_ModelViewMatrixTranspose,
 287        STATE_MODELVIEW_MATRIX, 0);
 288 MATRIX(gl_ModelViewMatrixInverseTranspose,
 289        STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE);
 290
 291 MATRIX(gl_ProjectionMatrix,
 292        STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE);
 293 MATRIX(gl_ProjectionMatrixInverse,
 294        STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS);
 295 MATRIX(gl_ProjectionMatrixTranspose,
 296        STATE_PROJECTION_MATRIX, 0);
 297 MATRIX(gl_ProjectionMatrixInverseTranspose,
 298        STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE);
 299
 300 MATRIX(gl_ModelViewProjectionMatrix,
 301        STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE);
 302 MATRIX(gl_ModelViewProjectionMatrixInverse,
 303        STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS);
 304 MATRIX(gl_ModelViewProjectionMatrixTranspose,
 305        STATE_MVP_MATRIX, 0);
 306 MATRIX(gl_ModelViewProjectionMatrixInverseTranspose,
 307        STATE_MVP_MATRIX, STATE_MATRIX_INVERSE);
 308
 309 MATRIX(gl_TextureMatrix,
 310        STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE);
 311 MATRIX(gl_TextureMatrixInverse,
 312        STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS);
 313 MATRIX(gl_TextureMatrixTranspose,
 314        STATE_TEXTURE_MATRIX, 0);
 315 MATRIX(gl_TextureMatrixInverseTranspose,
 316        STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE);
 317
 318 static struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = {
 319    { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE},
 320      MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
 321    { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE},
 322      MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
 323    { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE},
 324      MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
 325 };
 326
 327 #undef MATRIX
 328
 329 #define STATEVAR(name) {#name, name ## _elements, Elements(name ## _elements)}
 330
 331 static const struct gl_builtin_uniform_desc _mesa_builtin_uniform_desc[] = {
 332    STATEVAR(gl_DepthRange),
 333    STATEVAR(gl_ClipPlane),
 334    STATEVAR(gl_Point),
 335    STATEVAR(gl_FrontMaterial),
 336    STATEVAR(gl_BackMaterial),
 337    STATEVAR(gl_LightSource),
 338    STATEVAR(gl_LightModel),
 339    STATEVAR(gl_FrontLightModelProduct),
 340    STATEVAR(gl_BackLightModelProduct),
 341    STATEVAR(gl_FrontLightProduct),
 342    STATEVAR(gl_BackLightProduct),
 343    STATEVAR(gl_TextureEnvColor),
 344    STATEVAR(gl_EyePlaneS),
 345    STATEVAR(gl_EyePlaneT),
 346    STATEVAR(gl_EyePlaneR),
 347    STATEVAR(gl_EyePlaneQ),
 348    STATEVAR(gl_ObjectPlaneS),
 349    STATEVAR(gl_ObjectPlaneT),
 350    STATEVAR(gl_ObjectPlaneR),
 351    STATEVAR(gl_ObjectPlaneQ),
 352    STATEVAR(gl_Fog),
 353
 354    STATEVAR(gl_ModelViewMatrix),
 355    STATEVAR(gl_ModelViewMatrixInverse),
 356    STATEVAR(gl_ModelViewMatrixTranspose),
 357    STATEVAR(gl_ModelViewMatrixInverseTranspose),
 358
 359    STATEVAR(gl_ProjectionMatrix),
 360    STATEVAR(gl_ProjectionMatrixInverse),
 361    STATEVAR(gl_ProjectionMatrixTranspose),
 362    STATEVAR(gl_ProjectionMatrixInverseTranspose),
 363
 364    STATEVAR(gl_ModelViewProjectionMatrix),
 365    STATEVAR(gl_ModelViewProjectionMatrixInverse),
 366    STATEVAR(gl_ModelViewProjectionMatrixTranspose),
 367    STATEVAR(gl_ModelViewProjectionMatrixInverseTranspose),
 368
 369    STATEVAR(gl_TextureMatrix),
 370    STATEVAR(gl_TextureMatrixInverse),
 371    STATEVAR(gl_TextureMatrixTranspose),
 372    STATEVAR(gl_TextureMatrixInverseTranspose),
 373
 374    STATEVAR(gl_NormalMatrix),
 375    STATEVAR(gl_NormalScale),
 376
 377    STATEVAR(gl_BumpRotMatrix0MESA),
 378    STATEVAR(gl_BumpRotMatrix1MESA),
 379    STATEVAR(gl_FogParamsOptimizedMESA),
 380    STATEVAR(gl_CurrentAttribVertMESA),
 381    STATEVAR(gl_CurrentAttribFragMESA),
 382
 383    {NULL, NULL, 0}
 384 };
 385
 386 static ir_variable *
 387 add_variable(exec_list *instructions, glsl_symbol_table *symtab,
 388              const char *name, const glsl_type *type,
 389              enum ir_variable_mode mode, int slot)
 390 {
 391    ir_variable *var = new(symtab) ir_variable(type, name, mode);
 392
 393    switch (var->mode) {
 394    case ir_var_auto:
 395    case ir_var_in:
 396    case ir_var_const_in:
 397    case ir_var_uniform:
 398    case ir_var_system_value:
 399       var->read_only = true;
 400       break;
 401    case ir_var_inout:
 402    case ir_var_out:
 403       break;
 404    default:
 405       assert(0);
 406       break;
 407    }
 408
 409    var->location = slot;
 410    var->explicit_location = (slot >= 0);
 411    var->explicit_index = 0;
 412
 413    /* Once the variable is created an initialized, add it to the symbol table
 414     * and add the declaration to the IR stream.
 415     */
 416    instructions->push_tail(var);
 417
 418    symtab->add_variable(var);
 419    return var;
 420 }
 421
 422 static ir_variable *
 423 add_uniform(exec_list *instructions, glsl_symbol_table *symtab,
 424             const char *name, const glsl_type *type)
 425 {
 426    ir_variable *const uni =
 427       add_variable(instructions, symtab, name, type, ir_var_uniform, -1);
 428
 429    unsigned i;
 430    for (i = 0; _mesa_builtin_uniform_desc[i].name != NULL; i++) {
 431       if (strcmp(_mesa_builtin_uniform_desc[i].name, name) == 0) {
 432          break;
 433       }
 434    }
 435
 436    assert(_mesa_builtin_uniform_desc[i].name != NULL);
 437    const struct gl_builtin_uniform_desc* const statevar =
 438       &_mesa_builtin_uniform_desc[i];
 439
 440    const unsigned array_count = type->is_array() ? type->length : 1;
 441    uni->num_state_slots = array_count * statevar->num_elements;
 442
 443    ir_state_slot *slots =
 444       ralloc_array(uni, ir_state_slot, uni->num_state_slots);
 445
 446    uni->state_slots = slots;
 447
 448    for (unsigned a = 0; a < array_count; a++) {
 449       for (unsigned j = 0; j < statevar->num_elements; j++) {
 450          struct gl_builtin_uniform_element *element = &statevar->elements[j];
 451
 452          memcpy(slots->tokens, element->tokens, sizeof(element->tokens));
 453          if (type->is_array()) {
 454             if (strcmp(name, "gl_CurrentAttribVertMESA") == 0 ||
 455                 strcmp(name, "gl_CurrentAttribFragMESA") == 0) {
 456                slots->tokens[2] = a;
 457             } else {
 458                slots->tokens[1] = a;
 459             }
 460          }
 461
 462          slots->swizzle = element->swizzle;
 463          slots++;
 464       }
 465    }
 466
 467    return uni;
 468 }
 469
 470 static void
 471 add_builtin_variable(exec_list *instructions, glsl_symbol_table *symtab,
 472                      const builtin_variable *proto)
 473 {
 474    /* Create a new variable declaration from the description supplied by
 475     * the caller.
 476     */
 477    const glsl_type *const type = symtab->get_type(proto->type);
 478
 479    assert(type != NULL);
 480
 481    if (proto->mode == ir_var_uniform) {
 482       add_uniform(instructions, symtab, proto->name, type);
 483    } else {
 484       add_variable(instructions, symtab, proto->name, type, proto->mode,
 485                    proto->slot);
 486    }
 487 }
 488
 489 static ir_variable *
 490 add_builtin_constant(exec_list *instructions, glsl_symbol_table *symtab,
 491                      const char *name, int value)
 492 {
 493    ir_variable *const var = add_variable(instructions, symtab,
 494                                          name, glsl_type::int_type,
 495                                          ir_var_auto, -1);
 496    var->constant_value = new(var) ir_constant(value);
 497    var->constant_initializer = new(var) ir_constant(value);
 498    var->has_initializer = true;
 499    return var;
 500 }
 501
 502 /* Several constants in GLSL ES have different names than normal desktop GLSL.
 503  * Therefore, this function should only be called on the ES path.
 504  */
 505 static void
 506 generate_100ES_uniforms(exec_list *instructions,
 507                      struct _mesa_glsl_parse_state *state)
 508 {
 509    glsl_symbol_table *const symtab = state->symbols;
 510
 511    add_builtin_constant(instructions, symtab, "gl_MaxVertexAttribs",
 512                         state->Const.MaxVertexAttribs);
 513    add_builtin_constant(instructions, symtab, "gl_MaxVertexUniformVectors",
 514                         state->Const.MaxVertexUniformComponents);
 515    add_builtin_constant(instructions, symtab, "gl_MaxVaryingVectors",
 516                         state->Const.MaxVaryingFloats / 4);
 517    add_builtin_constant(instructions, symtab, "gl_MaxVertexTextureImageUnits",
 518                         state->Const.MaxVertexTextureImageUnits);
 519    add_builtin_constant(instructions, symtab, "gl_MaxCombinedTextureImageUnits",
 520                         state->Const.MaxCombinedTextureImageUnits);
 521    add_builtin_constant(instructions, symtab, "gl_MaxTextureImageUnits",
 522                         state->Const.MaxTextureImageUnits);
 523    add_builtin_constant(instructions, symtab, "gl_MaxFragmentUniformVectors",
 524                         state->Const.MaxFragmentUniformComponents);
 525
 526    add_uniform(instructions, symtab, "gl_DepthRange",
 527                state->symbols->get_type("gl_DepthRangeParameters"));
 528 }
 529
 530 static void
 531 generate_110_uniforms(exec_list *instructions,
 532                       struct _mesa_glsl_parse_state *state,
 533                       bool add_deprecated)
 534 {
 535    glsl_symbol_table *const symtab = state->symbols;
 536
 537    if (add_deprecated) {
 538       for (unsigned i = 0
 539               ; i < Elements(builtin_110_deprecated_uniforms)
 540               ; i++) {
 541          add_builtin_variable(instructions, symtab,
 542                               & builtin_110_deprecated_uniforms[i]);
 543       }
 544    }
 545
 546    if (add_deprecated) {
 547       add_builtin_constant(instructions, symtab, "gl_MaxLights",
 548                            state->Const.MaxLights);
 549       add_builtin_constant(instructions, symtab, "gl_MaxClipPlanes",
 550                            state->Const.MaxClipPlanes);
 551       add_builtin_constant(instructions, symtab, "gl_MaxTextureUnits",
 552                            state->Const.MaxTextureUnits);
 553       add_builtin_constant(instructions, symtab, "gl_MaxTextureCoords",
 554                            state->Const.MaxTextureCoords);
 555    }
 556    add_builtin_constant(instructions, symtab, "gl_MaxVertexAttribs",
 557                         state->Const.MaxVertexAttribs);
 558    add_builtin_constant(instructions, symtab, "gl_MaxVertexUniformComponents",
 559                         state->Const.MaxVertexUniformComponents);
 560    add_builtin_constant(instructions, symtab, "gl_MaxVaryingFloats",
 561                         state->Const.MaxVaryingFloats);
 562    add_builtin_constant(instructions, symtab, "gl_MaxVertexTextureImageUnits",
 563                         state->Const.MaxVertexTextureImageUnits);
 564    add_builtin_constant(instructions, symtab, "gl_MaxCombinedTextureImageUnits",
 565                         state->Const.MaxCombinedTextureImageUnits);
 566    add_builtin_constant(instructions, symtab, "gl_MaxTextureImageUnits",
 567                         state->Const.MaxTextureImageUnits);
 568    add_builtin_constant(instructions, symtab, "gl_MaxFragmentUniformComponents",
 569                         state->Const.MaxFragmentUniformComponents);
 570
 571    if (add_deprecated) {
 572       const glsl_type *const mat4_array_type =
 573          glsl_type::get_array_instance(glsl_type::mat4_type,
 574                                        state->Const.MaxTextureCoords);
 575
 576       add_uniform(instructions, symtab, "gl_TextureMatrix", mat4_array_type);
 577       add_uniform(instructions, symtab, "gl_TextureMatrixInverse", mat4_array_type);
 578       add_uniform(instructions, symtab, "gl_TextureMatrixTranspose", mat4_array_type);
 579       add_uniform(instructions, symtab, "gl_TextureMatrixInverseTranspose", mat4_array_type);
 580    }
 581
 582    add_uniform(instructions, symtab, "gl_DepthRange",
 583                 symtab->get_type("gl_DepthRangeParameters"));
 584
 585    if (add_deprecated) {
 586       add_uniform(instructions, symtab, "gl_ClipPlane",
 587                   glsl_type::get_array_instance(glsl_type::vec4_type,
 588                                                 state->Const.MaxClipPlanes));
 589       add_uniform(instructions, symtab, "gl_Point",
 590                   symtab->get_type("gl_PointParameters"));
 591
 592       const glsl_type *const material_parameters_type =
 593          symtab->get_type("gl_MaterialParameters");
 594       add_uniform(instructions, symtab, "gl_FrontMaterial", material_parameters_type);
 595       add_uniform(instructions, symtab, "gl_BackMaterial", material_parameters_type);
 596
 597       const glsl_type *const light_source_array_type =
 598          glsl_type::get_array_instance(symtab->get_type("gl_LightSourceParameters"), state->Const.MaxLights);
 599
 600       add_uniform(instructions, symtab, "gl_LightSource", light_source_array_type);
 601
 602       const glsl_type *const light_model_products_type =
 603          symtab->get_type("gl_LightModelProducts");
 604       add_uniform(instructions, symtab, "gl_FrontLightModelProduct",
 605                   light_model_products_type);
 606       add_uniform(instructions, symtab, "gl_BackLightModelProduct",
 607                   light_model_products_type);
 608
 609       const glsl_type *const light_products_type =
 610          glsl_type::get_array_instance(symtab->get_type("gl_LightProducts"),
 611                                        state->Const.MaxLights);
 612       add_uniform(instructions, symtab, "gl_FrontLightProduct", light_products_type);
 613       add_uniform(instructions, symtab, "gl_BackLightProduct", light_products_type);
 614
 615       add_uniform(instructions, symtab, "gl_TextureEnvColor",
 616                   glsl_type::get_array_instance(glsl_type::vec4_type,
 617                                                 state->Const.MaxTextureUnits));
 618
 619       const glsl_type *const texcoords_vec4 =
 620          glsl_type::get_array_instance(glsl_type::vec4_type,
 621                                        state->Const.MaxTextureCoords);
 622       add_uniform(instructions, symtab, "gl_EyePlaneS", texcoords_vec4);
 623       add_uniform(instructions, symtab, "gl_EyePlaneT", texcoords_vec4);
 624       add_uniform(instructions, symtab, "gl_EyePlaneR", texcoords_vec4);
 625       add_uniform(instructions, symtab, "gl_EyePlaneQ", texcoords_vec4);
 626       add_uniform(instructions, symtab, "gl_ObjectPlaneS", texcoords_vec4);
 627       add_uniform(instructions, symtab, "gl_ObjectPlaneT", texcoords_vec4);
 628       add_uniform(instructions, symtab, "gl_ObjectPlaneR", texcoords_vec4);
 629       add_uniform(instructions, symtab, "gl_ObjectPlaneQ", texcoords_vec4);
 630
 631       add_uniform(instructions, symtab, "gl_Fog",
 632                   symtab->get_type("gl_FogParameters"));
 633    }
 634
 635    /* Mesa-internal current attrib state */
 636    const glsl_type *const vert_attribs =
 637       glsl_type::get_array_instance(glsl_type::vec4_type, VERT_ATTRIB_MAX);
 638    add_uniform(instructions, symtab, "gl_CurrentAttribVertMESA", vert_attribs);
 639    const glsl_type *const frag_attribs =
 640       glsl_type::get_array_instance(glsl_type::vec4_type, FRAG_ATTRIB_MAX);
 641    add_uniform(instructions, symtab, "gl_CurrentAttribFragMESA", frag_attribs);
 642 }
 643
 644 /* This function should only be called for ES, not desktop GL. */
 645 static void
 646 generate_100ES_vs_variables(exec_list *instructions,
 647                           struct _mesa_glsl_parse_state *state)
 648 {
 649    for (unsigned i = 0; i < Elements(builtin_core_vs_variables); i++) {
 650       add_builtin_variable(instructions, state->symbols,
 651                            & builtin_core_vs_variables[i]);
 652    }
 653
 654    generate_100ES_uniforms(instructions, state);
 655
 656    generate_ARB_draw_buffers_variables(instructions, state, false,
 657                                        vertex_shader);
 658 }
 659
 660
 661 static void
 662 generate_110_vs_variables(exec_list *instructions,
 663                           struct _mesa_glsl_parse_state *state,
 664                           bool add_deprecated)
 665 {
 666    for (unsigned i = 0; i < Elements(builtin_core_vs_variables); i++) {
 667       add_builtin_variable(instructions, state->symbols,
 668                            & builtin_core_vs_variables[i]);
 669    }
 670
 671    if (add_deprecated) {
 672       for (unsigned i = 0
 673               ; i < Elements(builtin_110_deprecated_vs_variables)
 674               ; i++) {
 675          add_builtin_variable(instructions, state->symbols,
 676                               & builtin_110_deprecated_vs_variables[i]);
 677       }
 678    }
 679    generate_110_uniforms(instructions, state, add_deprecated);
 680
 681    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
 682     *
 683     *     "As with all arrays, indices used to subscript gl_TexCoord must
 684     *     either be an integral constant expressions, or this array must be
 685     *     re-declared by the shader with a size. The size can be at most
 686     *     gl_MaxTextureCoords. Using indexes close to 0 may aid the
 687     *     implementation in preserving varying resources."
 688     */
 689    const glsl_type *const vec4_array_type =
 690       glsl_type::get_array_instance(glsl_type::vec4_type, 0);
 691
 692    add_variable(instructions, state->symbols,
 693                 "gl_TexCoord", vec4_array_type, ir_var_out, VERT_RESULT_TEX0);
 694
 695    generate_ARB_draw_buffers_variables(instructions, state, false,
 696                                        vertex_shader);
 697 }
 698
 699
 700 static void
 701 generate_120_vs_variables(exec_list *instructions,
 702                           struct _mesa_glsl_parse_state *state,
 703                           bool add_deprecated)
 704 {
 705    /* GLSL version 1.20 did not add any built-in variables in the vertex
 706     * shader.
 707     */
 708    generate_110_vs_variables(instructions, state, add_deprecated);
 709 }
 710
 711
 712 static void
 713 generate_130_uniforms(exec_list *instructions,
 714                       struct _mesa_glsl_parse_state *state)
 715 {
 716    glsl_symbol_table *const symtab = state->symbols;
 717
 718    add_builtin_constant(instructions, symtab, "gl_MaxClipDistances",
 719                         state->Const.MaxClipPlanes);
 720    add_builtin_constant(instructions, symtab, "gl_MaxVaryingComponents",
 721                         state->Const.MaxVaryingFloats);
 722 }
 723
 724
 725 static void
 726 generate_130_vs_variables(exec_list *instructions,
 727                           struct _mesa_glsl_parse_state *state,
 728                           bool add_deprecated)
 729 {
 730    generate_120_vs_variables(instructions, state, add_deprecated);
 731
 732    for (unsigned i = 0; i < Elements(builtin_130_vs_variables); i++) {
 733       add_builtin_variable(instructions, state->symbols,
 734                            & builtin_130_vs_variables[i]);
 735    }
 736
 737    generate_130_uniforms(instructions, state);
 738
 739    /* From the GLSL 1.30 spec, section 7.1 (Vertex Shader Special
 740     * Variables):
 741     *
 742     *   The gl_ClipDistance array is predeclared as unsized and must
 743     *   be sized by the shader either redeclaring it with a size or
 744     *   indexing it only with integral constant expressions.
 745     *
 746     * We represent this in Mesa by initially declaring the array as
 747     * size 0.
 748     */
 749    const glsl_type *const clip_distance_array_type =
 750       glsl_type::get_array_instance(glsl_type::float_type, 0);
 751
 752    add_variable(instructions, state->symbols,
 753                 "gl_ClipDistance", clip_distance_array_type, ir_var_out,
 754                 VERT_RESULT_CLIP_DIST0);
 755
 756 }
 757
 758
 759 static void
 760 initialize_vs_variables(exec_list *instructions,
 761                         struct _mesa_glsl_parse_state *state)
 762 {
 763
 764    switch (state->language_version) {
 765    case 100:
 766       generate_100ES_vs_variables(instructions, state);
 767       break;
 768    case 110:
 769       generate_110_vs_variables(instructions, state, true);
 770       break;
 771    case 120:
 772       generate_120_vs_variables(instructions, state, true);
 773       break;
 774    case 130:
 775       generate_130_vs_variables(instructions, state, true);
 776       break;
 777    case 140:
 778       generate_130_vs_variables(instructions, state, false);
 779       break;
 780    }
 781
 782    generate_ARB_draw_instanced_variables(instructions, state, false,
 783                                          vertex_shader);
 784 }
 785
 786
 787 /* This function should only be called for ES, not desktop GL. */
 788 static void
 789 generate_100ES_fs_variables(exec_list *instructions,
 790                           struct _mesa_glsl_parse_state *state)
 791 {
 792    for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
 793       add_builtin_variable(instructions, state->symbols,
 794                            & builtin_core_fs_variables[i]);
 795    }
 796
 797    for (unsigned i = 0; i < Elements(builtin_100ES_fs_variables); i++) {
 798       add_builtin_variable(instructions, state->symbols,
 799                            & builtin_100ES_fs_variables[i]);
 800    }
 801
 802    generate_100ES_uniforms(instructions, state);
 803
 804    generate_ARB_draw_buffers_variables(instructions, state, false,
 805                                        fragment_shader);
 806 }
 807
 808 static void
 809 generate_110_fs_variables(exec_list *instructions,
 810                           struct _mesa_glsl_parse_state *state,
 811                           bool add_deprecated)
 812 {
 813    for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
 814       add_builtin_variable(instructions, state->symbols,
 815                            & builtin_core_fs_variables[i]);
 816    }
 817
 818    for (unsigned i = 0; i < Elements(builtin_110_fs_variables); i++) {
 819       add_builtin_variable(instructions, state->symbols,
 820                            & builtin_110_fs_variables[i]);
 821    }
 822
 823    if (add_deprecated) {
 824       for (unsigned i = 0
 825               ; i < Elements(builtin_110_deprecated_fs_variables)
 826               ; i++) {
 827          add_builtin_variable(instructions, state->symbols,
 828                               & builtin_110_deprecated_fs_variables[i]);
 829       }
 830    }
 831
 832    generate_110_uniforms(instructions, state, add_deprecated);
 833
 834    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
 835     *
 836     *     "As with all arrays, indices used to subscript gl_TexCoord must
 837     *     either be an integral constant expressions, or this array must be
 838     *     re-declared by the shader with a size. The size can be at most
 839     *     gl_MaxTextureCoords. Using indexes close to 0 may aid the
 840     *     implementation in preserving varying resources."
 841     */
 842    const glsl_type *const vec4_array_type =
 843       glsl_type::get_array_instance(glsl_type::vec4_type, 0);
 844
 845    add_variable(instructions, state->symbols,
 846                 "gl_TexCoord", vec4_array_type, ir_var_in, FRAG_ATTRIB_TEX0);
 847
 848    generate_ARB_draw_buffers_variables(instructions, state, false,
 849                                        fragment_shader);
 850 }
 851
 852
 853 static void
 854 generate_ARB_draw_buffers_variables(exec_list *instructions,
 855                                     struct _mesa_glsl_parse_state *state,
 856                                     bool warn, _mesa_glsl_parser_targets target)
 857 {
 858    /* gl_MaxDrawBuffers is available in all shader stages.
 859     */
 860    ir_variable *const mdb =
 861       add_builtin_constant(instructions, state->symbols, "gl_MaxDrawBuffers",
 862                            state->Const.MaxDrawBuffers);
 863
 864    if (warn)
 865       mdb->warn_extension = "GL_ARB_draw_buffers";
 866
 867    /* gl_FragData is only available in the fragment shader.
 868     */
 869    if (target == fragment_shader) {
 870       const glsl_type *const vec4_array_type =
 871          glsl_type::get_array_instance(glsl_type::vec4_type,
 872                                        state->Const.MaxDrawBuffers);
 873
 874       ir_variable *const fd =
 875          add_variable(instructions, state->symbols,
 876                       "gl_FragData", vec4_array_type,
 877                       ir_var_out, FRAG_RESULT_DATA0);
 878
 879       if (warn)
 880          fd->warn_extension = "GL_ARB_draw_buffers";
 881    }
 882 }
 883
 884
 885 static void
 886 generate_ARB_draw_instanced_variables(exec_list *instructions,
 887                                       struct _mesa_glsl_parse_state *state,
 888                                       bool warn,
 889                                       _mesa_glsl_parser_targets target)
 890 {
 891    /* gl_InstanceIDARB is only available in the vertex shader.
 892     */
 893    if (target != vertex_shader)
 894       return;
 895
 896    if (state->ARB_draw_instanced_enable) {
 897       ir_variable *inst =
 898          add_variable(instructions, state->symbols,
 899                       "gl_InstanceIDARB", glsl_type::int_type,
 900                       ir_var_system_value, SYSTEM_VALUE_INSTANCE_ID);
 901
 902       if (warn)
 903          inst->warn_extension = "GL_ARB_draw_instanced";
 904    }
 905
 906    if (state->ARB_draw_instanced_enable || state->language_version >= 140) {
 907       /* Originally ARB_draw_instanced only specified that ARB decorated name.
 908        * Since no vendor actually implemented that behavior and some apps use
 909        * the undecorated name, the extension now specifies that both names are
 910        * available.
 911        */
 912       ir_variable *inst =
 913          add_variable(instructions, state->symbols,
 914                       "gl_InstanceID", glsl_type::int_type,
 915                       ir_var_system_value, SYSTEM_VALUE_INSTANCE_ID);
 916
 917       if (state->language_version < 140 && warn)
 918          inst->warn_extension = "GL_ARB_draw_instanced";
 919    }
 920 }
 921
 922
 923 static void
 924 generate_ARB_shader_stencil_export_variables(exec_list *instructions,
 925                                              struct _mesa_glsl_parse_state *state,
 926                                              bool warn)
 927 {
 928    /* gl_FragStencilRefARB is only available in the fragment shader.
 929     */
 930    ir_variable *const fd =
 931       add_variable(instructions, state->symbols,
 932                    "gl_FragStencilRefARB", glsl_type::int_type,
 933                    ir_var_out, FRAG_RESULT_STENCIL);
 934
 935    if (warn)
 936       fd->warn_extension = "GL_ARB_shader_stencil_export";
 937 }
 938
 939 static void
 940 generate_AMD_shader_stencil_export_variables(exec_list *instructions,
 941                                              struct _mesa_glsl_parse_state *state,
 942                                              bool warn)
 943 {
 944    /* gl_FragStencilRefAMD is only available in the fragment shader.
 945     */
 946    ir_variable *const fd =
 947       add_variable(instructions, state->symbols,
 948                    "gl_FragStencilRefAMD", glsl_type::int_type,
 949                    ir_var_out, FRAG_RESULT_STENCIL);
 950
 951    if (warn)
 952       fd->warn_extension = "GL_AMD_shader_stencil_export";
 953 }
 954
 955 static void
 956 generate_120_fs_variables(exec_list *instructions,
 957                           struct _mesa_glsl_parse_state *state,
 958                           bool add_deprecated)
 959 {
 960    generate_110_fs_variables(instructions, state, add_deprecated);
 961
 962    for (unsigned i = 0
 963            ; i < Elements(builtin_120_fs_variables)
 964            ; i++) {
 965       add_builtin_variable(instructions, state->symbols,
 966                            & builtin_120_fs_variables[i]);
 967    }
 968 }
 969
 970 static void
 971 generate_fs_clipdistance(exec_list *instructions,
 972                          struct _mesa_glsl_parse_state *state)
 973 {
 974    /* From the GLSL 1.30 spec, section 7.2 (Fragment Shader Special
 975     * Variables):
 976     *
 977     *   The built-in input variable gl_ClipDistance array contains linearly
 978     *   interpolated values for the vertex values written by the vertex shader
 979     *   to the gl_ClipDistance vertex output variable. This array must be
 980     *   sized in the fragment shader either implicitly or explicitly to be the
 981     *   same size as it was sized in the vertex shader.
 982     *
 983     * In other words, the array must be pre-declared as implicitly sized.  We
 984     * represent this in Mesa by initially declaring the array as size 0.
 985     */
 986    const glsl_type *const clip_distance_array_type =
 987       glsl_type::get_array_instance(glsl_type::float_type, 0);
 988
 989    add_variable(instructions, state->symbols,
 990                 "gl_ClipDistance", clip_distance_array_type, ir_var_in,
 991                 FRAG_ATTRIB_CLIP_DIST0);
 992 }
 993
 994 static void
 995 generate_130_fs_variables(exec_list *instructions,
 996                           struct _mesa_glsl_parse_state *state)
 997 {
 998    generate_120_fs_variables(instructions, state, true);
 999
1000    generate_130_uniforms(instructions, state);
1001    generate_fs_clipdistance(instructions, state);
1002 }
1003
1004
1005 static void
1006 generate_140_fs_variables(exec_list *instructions,
1007                           struct _mesa_glsl_parse_state *state)
1008 {
1009    generate_120_fs_variables(instructions, state, false);
1010
1011    generate_130_uniforms(instructions, state);
1012    generate_fs_clipdistance(instructions, state);
1013 }
1014
1015 static void
1016 initialize_fs_variables(exec_list *instructions,
1017                         struct _mesa_glsl_parse_state *state)
1018 {
1019
1020    switch (state->language_version) {
1021    case 100:
1022       generate_100ES_fs_variables(instructions, state);
1023       break;
1024    case 110:
1025       generate_110_fs_variables(instructions, state, true);
1026       break;
1027    case 120:
1028       generate_120_fs_variables(instructions, state, true);
1029       break;
1030    case 130:
1031       generate_130_fs_variables(instructions, state);
1032       break;
1033    case 140:
1034       generate_140_fs_variables(instructions, state);
1035       break;
1036    }
1037
1038    if (state->ARB_shader_stencil_export_enable)
1039       generate_ARB_shader_stencil_export_variables(instructions, state,
1040                                                    state->ARB_shader_stencil_export_warn);
1041
1042    if (state->AMD_shader_stencil_export_enable)
1043       generate_AMD_shader_stencil_export_variables(instructions, state,
1044                                                    state->AMD_shader_stencil_export_warn);
1045 }
1046
1047 void
1048 _mesa_glsl_initialize_variables(exec_list *instructions,
1049                                 struct _mesa_glsl_parse_state *state)
1050 {
1051    switch (state->target) {
1052    case vertex_shader:
1053       initialize_vs_variables(instructions, state);
1054       break;
1055    case geometry_shader:
1056       break;
1057    case fragment_shader:
1058       initialize_fs_variables(instructions, state);
1059       break;
1060    }
1061 }