Home | History | Annotate | Download | only in glsl
      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 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 }
   1062