Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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. /**
  25.  * \file linker.cpp
  26.  * GLSL linker implementation
  27.  *
  28.  * Given a set of shaders that are to be linked to generate a final program,
  29.  * there are three distinct stages.
  30.  *
  31.  * In the first stage shaders are partitioned into groups based on the shader
  32.  * type.  All shaders of a particular type (e.g., vertex shaders) are linked
  33.  * together.
  34.  *
  35.  *   - Undefined references in each shader are resolve to definitions in
  36.  *     another shader.
  37.  *   - Types and qualifiers of uniforms, outputs, and global variables defined
  38.  *     in multiple shaders with the same name are verified to be the same.
  39.  *   - Initializers for uniforms and global variables defined
  40.  *     in multiple shaders with the same name are verified to be the same.
  41.  *
  42.  * The result, in the terminology of the GLSL spec, is a set of shader
  43.  * executables for each processing unit.
  44.  *
  45.  * After the first stage is complete, a series of semantic checks are performed
  46.  * on each of the shader executables.
  47.  *
  48.  *   - Each shader executable must define a \c main function.
  49.  *   - Each vertex shader executable must write to \c gl_Position.
  50.  *   - Each fragment shader executable must write to either \c gl_FragData or
  51.  *     \c gl_FragColor.
  52.  *
  53.  * In the final stage individual shader executables are linked to create a
  54.  * complete exectuable.
  55.  *
  56.  *   - Types of uniforms defined in multiple shader stages with the same name
  57.  *     are verified to be the same.
  58.  *   - Initializers for uniforms defined in multiple shader stages with the
  59.  *     same name are verified to be the same.
  60.  *   - Types and qualifiers of outputs defined in one stage are verified to
  61.  *     be the same as the types and qualifiers of inputs defined with the same
  62.  *     name in a later stage.
  63.  *
  64.  * \author Ian Romanick <ian.d.romanick@intel.com>
  65.  */
  66.  
  67. #include <ctype.h>
  68. #include "main/core.h"
  69. #include "glsl_symbol_table.h"
  70. #include "glsl_parser_extras.h"
  71. #include "ir.h"
  72. #include "program.h"
  73. #include "program/hash_table.h"
  74. #include "linker.h"
  75. #include "link_varyings.h"
  76. #include "ir_optimization.h"
  77. #include "ir_rvalue_visitor.h"
  78. #include "ir_uniform.h"
  79.  
  80. #include "main/shaderobj.h"
  81. #include "main/enums.h"
  82.  
  83.  
  84. void linker_error(gl_shader_program *, const char *, ...);
  85.  
  86. namespace {
  87.  
  88. /**
  89.  * Visitor that determines whether or not a variable is ever written.
  90.  */
  91. class find_assignment_visitor : public ir_hierarchical_visitor {
  92. public:
  93.    find_assignment_visitor(const char *name)
  94.       : name(name), found(false)
  95.    {
  96.       /* empty */
  97.    }
  98.  
  99.    virtual ir_visitor_status visit_enter(ir_assignment *ir)
  100.    {
  101.       ir_variable *const var = ir->lhs->variable_referenced();
  102.  
  103.       if (strcmp(name, var->name) == 0) {
  104.          found = true;
  105.          return visit_stop;
  106.       }
  107.  
  108.       return visit_continue_with_parent;
  109.    }
  110.  
  111.    virtual ir_visitor_status visit_enter(ir_call *ir)
  112.    {
  113.       foreach_two_lists(formal_node, &ir->callee->parameters,
  114.                         actual_node, &ir->actual_parameters) {
  115.          ir_rvalue *param_rval = (ir_rvalue *) actual_node;
  116.          ir_variable *sig_param = (ir_variable *) formal_node;
  117.  
  118.          if (sig_param->data.mode == ir_var_function_out ||
  119.              sig_param->data.mode == ir_var_function_inout) {
  120.             ir_variable *var = param_rval->variable_referenced();
  121.             if (var && strcmp(name, var->name) == 0) {
  122.                found = true;
  123.                return visit_stop;
  124.             }
  125.          }
  126.       }
  127.  
  128.       if (ir->return_deref != NULL) {
  129.          ir_variable *const var = ir->return_deref->variable_referenced();
  130.  
  131.          if (strcmp(name, var->name) == 0) {
  132.             found = true;
  133.             return visit_stop;
  134.          }
  135.       }
  136.  
  137.       return visit_continue_with_parent;
  138.    }
  139.  
  140.    bool variable_found()
  141.    {
  142.       return found;
  143.    }
  144.  
  145. private:
  146.    const char *name;       /**< Find writes to a variable with this name. */
  147.    bool found;             /**< Was a write to the variable found? */
  148. };
  149.  
  150.  
  151. /**
  152.  * Visitor that determines whether or not a variable is ever read.
  153.  */
  154. class find_deref_visitor : public ir_hierarchical_visitor {
  155. public:
  156.    find_deref_visitor(const char *name)
  157.       : name(name), found(false)
  158.    {
  159.       /* empty */
  160.    }
  161.  
  162.    virtual ir_visitor_status visit(ir_dereference_variable *ir)
  163.    {
  164.       if (strcmp(this->name, ir->var->name) == 0) {
  165.          this->found = true;
  166.          return visit_stop;
  167.       }
  168.  
  169.       return visit_continue;
  170.    }
  171.  
  172.    bool variable_found() const
  173.    {
  174.       return this->found;
  175.    }
  176.  
  177. private:
  178.    const char *name;       /**< Find writes to a variable with this name. */
  179.    bool found;             /**< Was a write to the variable found? */
  180. };
  181.  
  182.  
  183. class geom_array_resize_visitor : public ir_hierarchical_visitor {
  184. public:
  185.    unsigned num_vertices;
  186.    gl_shader_program *prog;
  187.  
  188.    geom_array_resize_visitor(unsigned num_vertices, gl_shader_program *prog)
  189.    {
  190.       this->num_vertices = num_vertices;
  191.       this->prog = prog;
  192.    }
  193.  
  194.    virtual ~geom_array_resize_visitor()
  195.    {
  196.       /* empty */
  197.    }
  198.  
  199.    virtual ir_visitor_status visit(ir_variable *var)
  200.    {
  201.       if (!var->type->is_array() || var->data.mode != ir_var_shader_in)
  202.          return visit_continue;
  203.  
  204.       unsigned size = var->type->length;
  205.  
  206.       /* Generate a link error if the shader has declared this array with an
  207.        * incorrect size.
  208.        */
  209.       if (size && size != this->num_vertices) {
  210.          linker_error(this->prog, "size of array %s declared as %u, "
  211.                       "but number of input vertices is %u\n",
  212.                       var->name, size, this->num_vertices);
  213.          return visit_continue;
  214.       }
  215.  
  216.       /* Generate a link error if the shader attempts to access an input
  217.        * array using an index too large for its actual size assigned at link
  218.        * time.
  219.        */
  220.       if (var->data.max_array_access >= this->num_vertices) {
  221.          linker_error(this->prog, "geometry shader accesses element %i of "
  222.                       "%s, but only %i input vertices\n",
  223.                       var->data.max_array_access, var->name, this->num_vertices);
  224.          return visit_continue;
  225.       }
  226.  
  227.       var->type = glsl_type::get_array_instance(var->type->element_type(),
  228.                                                 this->num_vertices);
  229.       var->data.max_array_access = this->num_vertices - 1;
  230.  
  231.       return visit_continue;
  232.    }
  233.  
  234.    /* Dereferences of input variables need to be updated so that their type
  235.     * matches the newly assigned type of the variable they are accessing. */
  236.    virtual ir_visitor_status visit(ir_dereference_variable *ir)
  237.    {
  238.       ir->type = ir->var->type;
  239.       return visit_continue;
  240.    }
  241.  
  242.    /* Dereferences of 2D input arrays need to be updated so that their type
  243.     * matches the newly assigned type of the array they are accessing. */
  244.    virtual ir_visitor_status visit_leave(ir_dereference_array *ir)
  245.    {
  246.       const glsl_type *const vt = ir->array->type;
  247.       if (vt->is_array())
  248.          ir->type = vt->element_type();
  249.       return visit_continue;
  250.    }
  251. };
  252.  
  253. /**
  254.  * Visitor that determines the highest stream id to which a (geometry) shader
  255.  * emits vertices. It also checks whether End{Stream}Primitive is ever called.
  256.  */
  257. class find_emit_vertex_visitor : public ir_hierarchical_visitor {
  258. public:
  259.    find_emit_vertex_visitor(int max_allowed)
  260.       : max_stream_allowed(max_allowed),
  261.         invalid_stream_id(0),
  262.         invalid_stream_id_from_emit_vertex(false),
  263.         end_primitive_found(false),
  264.         uses_non_zero_stream(false)
  265.    {
  266.       /* empty */
  267.    }
  268.  
  269.    virtual ir_visitor_status visit_leave(ir_emit_vertex *ir)
  270.    {
  271.       int stream_id = ir->stream_id();
  272.  
  273.       if (stream_id < 0) {
  274.          invalid_stream_id = stream_id;
  275.          invalid_stream_id_from_emit_vertex = true;
  276.          return visit_stop;
  277.       }
  278.  
  279.       if (stream_id > max_stream_allowed) {
  280.          invalid_stream_id = stream_id;
  281.          invalid_stream_id_from_emit_vertex = true;
  282.          return visit_stop;
  283.       }
  284.  
  285.       if (stream_id != 0)
  286.          uses_non_zero_stream = true;
  287.  
  288.       return visit_continue;
  289.    }
  290.  
  291.    virtual ir_visitor_status visit_leave(ir_end_primitive *ir)
  292.    {
  293.       end_primitive_found = true;
  294.  
  295.       int stream_id = ir->stream_id();
  296.  
  297.       if (stream_id < 0) {
  298.          invalid_stream_id = stream_id;
  299.          invalid_stream_id_from_emit_vertex = false;
  300.          return visit_stop;
  301.       }
  302.  
  303.       if (stream_id > max_stream_allowed) {
  304.          invalid_stream_id = stream_id;
  305.          invalid_stream_id_from_emit_vertex = false;
  306.          return visit_stop;
  307.       }
  308.  
  309.       if (stream_id != 0)
  310.          uses_non_zero_stream = true;
  311.  
  312.       return visit_continue;
  313.    }
  314.  
  315.    bool error()
  316.    {
  317.       return invalid_stream_id != 0;
  318.    }
  319.  
  320.    const char *error_func()
  321.    {
  322.       return invalid_stream_id_from_emit_vertex ?
  323.          "EmitStreamVertex" : "EndStreamPrimitive";
  324.    }
  325.  
  326.    int error_stream()
  327.    {
  328.       return invalid_stream_id;
  329.    }
  330.  
  331.    bool uses_streams()
  332.    {
  333.       return uses_non_zero_stream;
  334.    }
  335.  
  336.    bool uses_end_primitive()
  337.    {
  338.       return end_primitive_found;
  339.    }
  340.  
  341. private:
  342.    int max_stream_allowed;
  343.    int invalid_stream_id;
  344.    bool invalid_stream_id_from_emit_vertex;
  345.    bool end_primitive_found;
  346.    bool uses_non_zero_stream;
  347. };
  348.  
  349. } /* anonymous namespace */
  350.  
  351. void
  352. linker_error(gl_shader_program *prog, const char *fmt, ...)
  353. {
  354.    va_list ap;
  355.  
  356.    ralloc_strcat(&prog->InfoLog, "error: ");
  357.    va_start(ap, fmt);
  358.    ralloc_vasprintf_append(&prog->InfoLog, fmt, ap);
  359.    va_end(ap);
  360.  
  361.    prog->LinkStatus = false;
  362. }
  363.  
  364.  
  365. void
  366. linker_warning(gl_shader_program *prog, const char *fmt, ...)
  367. {
  368.    va_list ap;
  369.  
  370.    ralloc_strcat(&prog->InfoLog, "warning: ");
  371.    va_start(ap, fmt);
  372.    ralloc_vasprintf_append(&prog->InfoLog, fmt, ap);
  373.    va_end(ap);
  374.  
  375. }
  376.  
  377.  
  378. /**
  379.  * Given a string identifying a program resource, break it into a base name
  380.  * and an optional array index in square brackets.
  381.  *
  382.  * If an array index is present, \c out_base_name_end is set to point to the
  383.  * "[" that precedes the array index, and the array index itself is returned
  384.  * as a long.
  385.  *
  386.  * If no array index is present (or if the array index is negative or
  387.  * mal-formed), \c out_base_name_end, is set to point to the null terminator
  388.  * at the end of the input string, and -1 is returned.
  389.  *
  390.  * Only the final array index is parsed; if the string contains other array
  391.  * indices (or structure field accesses), they are left in the base name.
  392.  *
  393.  * No attempt is made to check that the base name is properly formed;
  394.  * typically the caller will look up the base name in a hash table, so
  395.  * ill-formed base names simply turn into hash table lookup failures.
  396.  */
  397. long
  398. parse_program_resource_name(const GLchar *name,
  399.                             const GLchar **out_base_name_end)
  400. {
  401.    /* Section 7.3.1 ("Program Interfaces") of the OpenGL 4.3 spec says:
  402.     *
  403.     *     "When an integer array element or block instance number is part of
  404.     *     the name string, it will be specified in decimal form without a "+"
  405.     *     or "-" sign or any extra leading zeroes. Additionally, the name
  406.     *     string will not include white space anywhere in the string."
  407.     */
  408.  
  409.    const size_t len = strlen(name);
  410.    *out_base_name_end = name + len;
  411.  
  412.    if (len == 0 || name[len-1] != ']')
  413.       return -1;
  414.  
  415.    /* Walk backwards over the string looking for a non-digit character.  This
  416.     * had better be the opening bracket for an array index.
  417.     *
  418.     * Initially, i specifies the location of the ']'.  Since the string may
  419.     * contain only the ']' charcater, walk backwards very carefully.
  420.     */
  421.    unsigned i;
  422.    for (i = len - 1; (i > 0) && isdigit(name[i-1]); --i)
  423.       /* empty */ ;
  424.  
  425.    if ((i == 0) || name[i-1] != '[')
  426.       return -1;
  427.  
  428.    long array_index = strtol(&name[i], NULL, 10);
  429.    if (array_index < 0)
  430.       return -1;
  431.  
  432.    *out_base_name_end = name + (i - 1);
  433.    return array_index;
  434. }
  435.  
  436.  
  437. void
  438. link_invalidate_variable_locations(exec_list *ir)
  439. {
  440.    foreach_in_list(ir_instruction, node, ir) {
  441.       ir_variable *const var = node->as_variable();
  442.  
  443.       if (var == NULL)
  444.          continue;
  445.  
  446.       /* Only assign locations for variables that lack an explicit location.
  447.        * Explicit locations are set for all built-in variables, generic vertex
  448.        * shader inputs (via layout(location=...)), and generic fragment shader
  449.        * outputs (also via layout(location=...)).
  450.        */
  451.       if (!var->data.explicit_location) {
  452.          var->data.location = -1;
  453.          var->data.location_frac = 0;
  454.       }
  455.  
  456.       /* ir_variable::is_unmatched_generic_inout is used by the linker while
  457.        * connecting outputs from one stage to inputs of the next stage.
  458.        *
  459.        * There are two implicit assumptions here.  First, we assume that any
  460.        * built-in variable (i.e., non-generic in or out) will have
  461.        * explicit_location set.  Second, we assume that any generic in or out
  462.        * will not have explicit_location set.
  463.        *
  464.        * This second assumption will only be valid until
  465.        * GL_ARB_separate_shader_objects is supported.  When that extension is
  466.        * implemented, this function will need some modifications.
  467.        */
  468.       if (!var->data.explicit_location) {
  469.          var->data.is_unmatched_generic_inout = 1;
  470.       } else {
  471.          var->data.is_unmatched_generic_inout = 0;
  472.       }
  473.    }
  474. }
  475.  
  476.  
  477. /**
  478.  * Set UsesClipDistance and ClipDistanceArraySize based on the given shader.
  479.  *
  480.  * Also check for errors based on incorrect usage of gl_ClipVertex and
  481.  * gl_ClipDistance.
  482.  *
  483.  * Return false if an error was reported.
  484.  */
  485. static void
  486. analyze_clip_usage(struct gl_shader_program *prog,
  487.                    struct gl_shader *shader, GLboolean *UsesClipDistance,
  488.                    GLuint *ClipDistanceArraySize)
  489. {
  490.    *ClipDistanceArraySize = 0;
  491.  
  492.    if (!prog->IsES && prog->Version >= 130) {
  493.       /* From section 7.1 (Vertex Shader Special Variables) of the
  494.        * GLSL 1.30 spec:
  495.        *
  496.        *   "It is an error for a shader to statically write both
  497.        *   gl_ClipVertex and gl_ClipDistance."
  498.        *
  499.        * This does not apply to GLSL ES shaders, since GLSL ES defines neither
  500.        * gl_ClipVertex nor gl_ClipDistance.
  501.        */
  502.       find_assignment_visitor clip_vertex("gl_ClipVertex");
  503.       find_assignment_visitor clip_distance("gl_ClipDistance");
  504.  
  505.       clip_vertex.run(shader->ir);
  506.       clip_distance.run(shader->ir);
  507.       if (clip_vertex.variable_found() && clip_distance.variable_found()) {
  508.          linker_error(prog, "%s shader writes to both `gl_ClipVertex' "
  509.                       "and `gl_ClipDistance'\n",
  510.                       _mesa_shader_stage_to_string(shader->Stage));
  511.          return;
  512.       }
  513.       *UsesClipDistance = clip_distance.variable_found();
  514.       ir_variable *clip_distance_var =
  515.          shader->symbols->get_variable("gl_ClipDistance");
  516.       if (clip_distance_var)
  517.          *ClipDistanceArraySize = clip_distance_var->type->length;
  518.    } else {
  519.       *UsesClipDistance = false;
  520.    }
  521. }
  522.  
  523.  
  524. /**
  525.  * Verify that a vertex shader executable meets all semantic requirements.
  526.  *
  527.  * Also sets prog->Vert.UsesClipDistance and prog->Vert.ClipDistanceArraySize
  528.  * as a side effect.
  529.  *
  530.  * \param shader  Vertex shader executable to be verified
  531.  */
  532. void
  533. validate_vertex_shader_executable(struct gl_shader_program *prog,
  534.                                   struct gl_shader *shader)
  535. {
  536.    if (shader == NULL)
  537.       return;
  538.  
  539.    /* From the GLSL 1.10 spec, page 48:
  540.     *
  541.     *     "The variable gl_Position is available only in the vertex
  542.     *      language and is intended for writing the homogeneous vertex
  543.     *      position. All executions of a well-formed vertex shader
  544.     *      executable must write a value into this variable. [...] The
  545.     *      variable gl_Position is available only in the vertex
  546.     *      language and is intended for writing the homogeneous vertex
  547.     *      position. All executions of a well-formed vertex shader
  548.     *      executable must write a value into this variable."
  549.     *
  550.     * while in GLSL 1.40 this text is changed to:
  551.     *
  552.     *     "The variable gl_Position is available only in the vertex
  553.     *      language and is intended for writing the homogeneous vertex
  554.     *      position. It can be written at any time during shader
  555.     *      execution. It may also be read back by a vertex shader
  556.     *      after being written. This value will be used by primitive
  557.     *      assembly, clipping, culling, and other fixed functionality
  558.     *      operations, if present, that operate on primitives after
  559.     *      vertex processing has occurred. Its value is undefined if
  560.     *      the vertex shader executable does not write gl_Position."
  561.     *
  562.     * All GLSL ES Versions are similar to GLSL 1.40--failing to write to
  563.     * gl_Position is not an error.
  564.     */
  565.    if (prog->Version < (prog->IsES ? 300 : 140)) {
  566.       find_assignment_visitor find("gl_Position");
  567.       find.run(shader->ir);
  568.       if (!find.variable_found()) {
  569.         if (prog->IsES) {
  570.           linker_warning(prog,
  571.                          "vertex shader does not write to `gl_Position'."
  572.                          "It's value is undefined. \n");
  573.         } else {
  574.           linker_error(prog,
  575.                        "vertex shader does not write to `gl_Position'. \n");
  576.         }
  577.          return;
  578.       }
  579.    }
  580.  
  581.    analyze_clip_usage(prog, shader, &prog->Vert.UsesClipDistance,
  582.                       &prog->Vert.ClipDistanceArraySize);
  583. }
  584.  
  585.  
  586. /**
  587.  * Verify that a fragment shader executable meets all semantic requirements
  588.  *
  589.  * \param shader  Fragment shader executable to be verified
  590.  */
  591. void
  592. validate_fragment_shader_executable(struct gl_shader_program *prog,
  593.                                     struct gl_shader *shader)
  594. {
  595.    if (shader == NULL)
  596.       return;
  597.  
  598.    find_assignment_visitor frag_color("gl_FragColor");
  599.    find_assignment_visitor frag_data("gl_FragData");
  600.  
  601.    frag_color.run(shader->ir);
  602.    frag_data.run(shader->ir);
  603.  
  604.    if (frag_color.variable_found() && frag_data.variable_found()) {
  605.       linker_error(prog,  "fragment shader writes to both "
  606.                    "`gl_FragColor' and `gl_FragData'\n");
  607.    }
  608. }
  609.  
  610. /**
  611.  * Verify that a geometry shader executable meets all semantic requirements
  612.  *
  613.  * Also sets prog->Geom.VerticesIn, prog->Geom.UsesClipDistance, and
  614.  * prog->Geom.ClipDistanceArraySize as a side effect.
  615.  *
  616.  * \param shader Geometry shader executable to be verified
  617.  */
  618. void
  619. validate_geometry_shader_executable(struct gl_shader_program *prog,
  620.                                     struct gl_shader *shader)
  621. {
  622.    if (shader == NULL)
  623.       return;
  624.  
  625.    unsigned num_vertices = vertices_per_prim(prog->Geom.InputType);
  626.    prog->Geom.VerticesIn = num_vertices;
  627.  
  628.    analyze_clip_usage(prog, shader, &prog->Geom.UsesClipDistance,
  629.                       &prog->Geom.ClipDistanceArraySize);
  630. }
  631.  
  632. /**
  633.  * Check if geometry shaders emit to non-zero streams and do corresponding
  634.  * validations.
  635.  */
  636. static void
  637. validate_geometry_shader_emissions(struct gl_context *ctx,
  638.                                    struct gl_shader_program *prog)
  639. {
  640.    if (prog->_LinkedShaders[MESA_SHADER_GEOMETRY] != NULL) {
  641.       find_emit_vertex_visitor emit_vertex(ctx->Const.MaxVertexStreams - 1);
  642.       emit_vertex.run(prog->_LinkedShaders[MESA_SHADER_GEOMETRY]->ir);
  643.       if (emit_vertex.error()) {
  644.          linker_error(prog, "Invalid call %s(%d). Accepted values for the "
  645.                       "stream parameter are in the range [0, %d].\n",
  646.                       emit_vertex.error_func(),
  647.                       emit_vertex.error_stream(),
  648.                       ctx->Const.MaxVertexStreams - 1);
  649.       }
  650.       prog->Geom.UsesStreams = emit_vertex.uses_streams();
  651.       prog->Geom.UsesEndPrimitive = emit_vertex.uses_end_primitive();
  652.  
  653.       /* From the ARB_gpu_shader5 spec:
  654.        *
  655.        *   "Multiple vertex streams are supported only if the output primitive
  656.        *    type is declared to be "points".  A program will fail to link if it
  657.        *    contains a geometry shader calling EmitStreamVertex() or
  658.        *    EndStreamPrimitive() if its output primitive type is not "points".
  659.        *
  660.        * However, in the same spec:
  661.        *
  662.        *   "The function EmitVertex() is equivalent to calling EmitStreamVertex()
  663.        *    with <stream> set to zero."
  664.        *
  665.        * And:
  666.        *
  667.        *   "The function EndPrimitive() is equivalent to calling
  668.        *    EndStreamPrimitive() with <stream> set to zero."
  669.        *
  670.        * Since we can call EmitVertex() and EndPrimitive() when we output
  671.        * primitives other than points, calling EmitStreamVertex(0) or
  672.        * EmitEndPrimitive(0) should not produce errors. This it also what Nvidia
  673.        * does. Currently we only set prog->Geom.UsesStreams to TRUE when
  674.        * EmitStreamVertex() or EmitEndPrimitive() are called with a non-zero
  675.        * stream.
  676.        */
  677.       if (prog->Geom.UsesStreams && prog->Geom.OutputType != GL_POINTS) {
  678.          linker_error(prog, "EmitStreamVertex(n) and EndStreamPrimitive(n) "
  679.                       "with n>0 requires point output\n");
  680.       }
  681.    }
  682. }
  683.  
  684. bool
  685. validate_intrastage_arrays(struct gl_shader_program *prog,
  686.                            ir_variable *const var,
  687.                            ir_variable *const existing)
  688. {
  689.    /* Consider the types to be "the same" if both types are arrays
  690.     * of the same type and one of the arrays is implicitly sized.
  691.     * In addition, set the type of the linked variable to the
  692.     * explicitly sized array.
  693.     */
  694.    if (var->type->is_array() && existing->type->is_array() &&
  695.        (var->type->fields.array == existing->type->fields.array) &&
  696.        ((var->type->length == 0)|| (existing->type->length == 0))) {
  697.       if (var->type->length != 0) {
  698.          if (var->type->length <= existing->data.max_array_access) {
  699.             linker_error(prog, "%s `%s' declared as type "
  700.                          "`%s' but outermost dimension has an index"
  701.                          " of `%i'\n",
  702.                          mode_string(var),
  703.                          var->name, var->type->name,
  704.                          existing->data.max_array_access);
  705.          }
  706.          existing->type = var->type;
  707.          return true;
  708.       } else if (existing->type->length != 0) {
  709.          if(existing->type->length <= var->data.max_array_access) {
  710.             linker_error(prog, "%s `%s' declared as type "
  711.                          "`%s' but outermost dimension has an index"
  712.                          " of `%i'\n",
  713.                          mode_string(var),
  714.                          var->name, existing->type->name,
  715.                          var->data.max_array_access);
  716.          }
  717.          return true;
  718.       }
  719.    }
  720.    return false;
  721. }
  722.  
  723.  
  724. /**
  725.  * Perform validation of global variables used across multiple shaders
  726.  */
  727. void
  728. cross_validate_globals(struct gl_shader_program *prog,
  729.                        struct gl_shader **shader_list,
  730.                        unsigned num_shaders,
  731.                        bool uniforms_only)
  732. {
  733.    /* Examine all of the uniforms in all of the shaders and cross validate
  734.     * them.
  735.     */
  736.    glsl_symbol_table variables;
  737.    for (unsigned i = 0; i < num_shaders; i++) {
  738.       if (shader_list[i] == NULL)
  739.          continue;
  740.  
  741.       foreach_in_list(ir_instruction, node, shader_list[i]->ir) {
  742.          ir_variable *const var = node->as_variable();
  743.  
  744.          if (var == NULL)
  745.             continue;
  746.  
  747.          if (uniforms_only && (var->data.mode != ir_var_uniform))
  748.             continue;
  749.  
  750.          /* Don't cross validate temporaries that are at global scope.  These
  751.           * will eventually get pulled into the shaders 'main'.
  752.           */
  753.          if (var->data.mode == ir_var_temporary)
  754.             continue;
  755.  
  756.          /* If a global with this name has already been seen, verify that the
  757.           * new instance has the same type.  In addition, if the globals have
  758.           * initializers, the values of the initializers must be the same.
  759.           */
  760.          ir_variable *const existing = variables.get_variable(var->name);
  761.          if (existing != NULL) {
  762.             /* Check if types match. Interface blocks have some special
  763.              * rules so we handle those elsewhere.
  764.              */
  765.            if (var->type != existing->type &&
  766.                 !var->is_interface_instance()) {
  767.                if (!validate_intrastage_arrays(prog, var, existing)) {
  768.                   if (var->type->is_record() && existing->type->is_record()
  769.                       && existing->type->record_compare(var->type)) {
  770.                      existing->type = var->type;
  771.                   } else {
  772.                      linker_error(prog, "%s `%s' declared as type "
  773.                                   "`%s' and type `%s'\n",
  774.                                   mode_string(var),
  775.                                   var->name, var->type->name,
  776.                                   existing->type->name);
  777.                      return;
  778.                   }
  779.                }
  780.             }
  781.  
  782.             if (var->data.explicit_location) {
  783.                if (existing->data.explicit_location
  784.                    && (var->data.location != existing->data.location)) {
  785.                      linker_error(prog, "explicit locations for %s "
  786.                                   "`%s' have differing values\n",
  787.                                   mode_string(var), var->name);
  788.                      return;
  789.                }
  790.  
  791.                existing->data.location = var->data.location;
  792.                existing->data.explicit_location = true;
  793.             }
  794.  
  795.             /* From the GLSL 4.20 specification:
  796.              * "A link error will result if two compilation units in a program
  797.              *  specify different integer-constant bindings for the same
  798.              *  opaque-uniform name.  However, it is not an error to specify a
  799.              *  binding on some but not all declarations for the same name"
  800.              */
  801.             if (var->data.explicit_binding) {
  802.                if (existing->data.explicit_binding &&
  803.                    var->data.binding != existing->data.binding) {
  804.                   linker_error(prog, "explicit bindings for %s "
  805.                                "`%s' have differing values\n",
  806.                                mode_string(var), var->name);
  807.                   return;
  808.                }
  809.  
  810.                existing->data.binding = var->data.binding;
  811.                existing->data.explicit_binding = true;
  812.             }
  813.  
  814.             if (var->type->contains_atomic() &&
  815.                 var->data.atomic.offset != existing->data.atomic.offset) {
  816.                linker_error(prog, "offset specifications for %s "
  817.                             "`%s' have differing values\n",
  818.                             mode_string(var), var->name);
  819.                return;
  820.             }
  821.  
  822.             /* Validate layout qualifiers for gl_FragDepth.
  823.              *
  824.              * From the AMD/ARB_conservative_depth specs:
  825.              *
  826.              *    "If gl_FragDepth is redeclared in any fragment shader in a
  827.              *    program, it must be redeclared in all fragment shaders in
  828.              *    that program that have static assignments to
  829.              *    gl_FragDepth. All redeclarations of gl_FragDepth in all
  830.              *    fragment shaders in a single program must have the same set
  831.              *    of qualifiers."
  832.              */
  833.             if (strcmp(var->name, "gl_FragDepth") == 0) {
  834.                bool layout_declared = var->data.depth_layout != ir_depth_layout_none;
  835.                bool layout_differs =
  836.                   var->data.depth_layout != existing->data.depth_layout;
  837.  
  838.                if (layout_declared && layout_differs) {
  839.                   linker_error(prog,
  840.                                "All redeclarations of gl_FragDepth in all "
  841.                                "fragment shaders in a single program must have "
  842.                                "the same set of qualifiers.\n");
  843.                }
  844.  
  845.                if (var->data.used && layout_differs) {
  846.                   linker_error(prog,
  847.                                "If gl_FragDepth is redeclared with a layout "
  848.                                "qualifier in any fragment shader, it must be "
  849.                                "redeclared with the same layout qualifier in "
  850.                                "all fragment shaders that have assignments to "
  851.                                "gl_FragDepth\n");
  852.                }
  853.             }
  854.  
  855.             /* Page 35 (page 41 of the PDF) of the GLSL 4.20 spec says:
  856.              *
  857.              *     "If a shared global has multiple initializers, the
  858.              *     initializers must all be constant expressions, and they
  859.              *     must all have the same value. Otherwise, a link error will
  860.              *     result. (A shared global having only one initializer does
  861.              *     not require that initializer to be a constant expression.)"
  862.              *
  863.              * Previous to 4.20 the GLSL spec simply said that initializers
  864.              * must have the same value.  In this case of non-constant
  865.              * initializers, this was impossible to determine.  As a result,
  866.              * no vendor actually implemented that behavior.  The 4.20
  867.              * behavior matches the implemented behavior of at least one other
  868.              * vendor, so we'll implement that for all GLSL versions.
  869.              */
  870.             if (var->constant_initializer != NULL) {
  871.                if (existing->constant_initializer != NULL) {
  872.                   if (!var->constant_initializer->has_value(existing->constant_initializer)) {
  873.                      linker_error(prog, "initializers for %s "
  874.                                   "`%s' have differing values\n",
  875.                                   mode_string(var), var->name);
  876.                      return;
  877.                   }
  878.                } else {
  879.                   /* If the first-seen instance of a particular uniform did not
  880.                    * have an initializer but a later instance does, copy the
  881.                    * initializer to the version stored in the symbol table.
  882.                    */
  883.                   /* FINISHME: This is wrong.  The constant_value field should
  884.                    * FINISHME: not be modified!  Imagine a case where a shader
  885.                    * FINISHME: without an initializer is linked in two different
  886.                    * FINISHME: programs with shaders that have differing
  887.                    * FINISHME: initializers.  Linking with the first will
  888.                    * FINISHME: modify the shader, and linking with the second
  889.                    * FINISHME: will fail.
  890.                    */
  891.                   existing->constant_initializer =
  892.                      var->constant_initializer->clone(ralloc_parent(existing),
  893.                                                       NULL);
  894.                }
  895.             }
  896.  
  897.             if (var->data.has_initializer) {
  898.                if (existing->data.has_initializer
  899.                    && (var->constant_initializer == NULL
  900.                        || existing->constant_initializer == NULL)) {
  901.                   linker_error(prog,
  902.                                "shared global variable `%s' has multiple "
  903.                                "non-constant initializers.\n",
  904.                                var->name);
  905.                   return;
  906.                }
  907.  
  908.                /* Some instance had an initializer, so keep track of that.  In
  909.                 * this location, all sorts of initializers (constant or
  910.                 * otherwise) will propagate the existence to the variable
  911.                 * stored in the symbol table.
  912.                 */
  913.                existing->data.has_initializer = true;
  914.             }
  915.  
  916.             if (existing->data.invariant != var->data.invariant) {
  917.                linker_error(prog, "declarations for %s `%s' have "
  918.                             "mismatching invariant qualifiers\n",
  919.                             mode_string(var), var->name);
  920.                return;
  921.             }
  922.             if (existing->data.centroid != var->data.centroid) {
  923.                linker_error(prog, "declarations for %s `%s' have "
  924.                             "mismatching centroid qualifiers\n",
  925.                             mode_string(var), var->name);
  926.                return;
  927.             }
  928.             if (existing->data.sample != var->data.sample) {
  929.                linker_error(prog, "declarations for %s `%s` have "
  930.                             "mismatching sample qualifiers\n",
  931.                             mode_string(var), var->name);
  932.                return;
  933.             }
  934.          } else
  935.             variables.add_variable(var);
  936.       }
  937.    }
  938. }
  939.  
  940.  
  941. /**
  942.  * Perform validation of uniforms used across multiple shader stages
  943.  */
  944. void
  945. cross_validate_uniforms(struct gl_shader_program *prog)
  946. {
  947.    cross_validate_globals(prog, prog->_LinkedShaders,
  948.                           MESA_SHADER_STAGES, true);
  949. }
  950.  
  951. /**
  952.  * Accumulates the array of prog->UniformBlocks and checks that all
  953.  * definitons of blocks agree on their contents.
  954.  */
  955. static bool
  956. interstage_cross_validate_uniform_blocks(struct gl_shader_program *prog)
  957. {
  958.    unsigned max_num_uniform_blocks = 0;
  959.    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  960.       if (prog->_LinkedShaders[i])
  961.          max_num_uniform_blocks += prog->_LinkedShaders[i]->NumUniformBlocks;
  962.    }
  963.  
  964.    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  965.       struct gl_shader *sh = prog->_LinkedShaders[i];
  966.  
  967.       prog->UniformBlockStageIndex[i] = ralloc_array(prog, int,
  968.                                                      max_num_uniform_blocks);
  969.       for (unsigned int j = 0; j < max_num_uniform_blocks; j++)
  970.          prog->UniformBlockStageIndex[i][j] = -1;
  971.  
  972.       if (sh == NULL)
  973.          continue;
  974.  
  975.       for (unsigned int j = 0; j < sh->NumUniformBlocks; j++) {
  976.          int index = link_cross_validate_uniform_block(prog,
  977.                                                        &prog->UniformBlocks,
  978.                                                        &prog->NumUniformBlocks,
  979.                                                        &sh->UniformBlocks[j]);
  980.  
  981.          if (index == -1) {
  982.             linker_error(prog, "uniform block `%s' has mismatching definitions\n",
  983.                          sh->UniformBlocks[j].Name);
  984.             return false;
  985.          }
  986.  
  987.          prog->UniformBlockStageIndex[i][index] = j;
  988.       }
  989.    }
  990.  
  991.    return true;
  992. }
  993.  
  994.  
  995. /**
  996.  * Populates a shaders symbol table with all global declarations
  997.  */
  998. static void
  999. populate_symbol_table(gl_shader *sh)
  1000. {
  1001.    sh->symbols = new(sh) glsl_symbol_table;
  1002.  
  1003.    foreach_in_list(ir_instruction, inst, sh->ir) {
  1004.       ir_variable *var;
  1005.       ir_function *func;
  1006.  
  1007.       if ((func = inst->as_function()) != NULL) {
  1008.          sh->symbols->add_function(func);
  1009.       } else if ((var = inst->as_variable()) != NULL) {
  1010.          if (var->data.mode != ir_var_temporary)
  1011.             sh->symbols->add_variable(var);
  1012.       }
  1013.    }
  1014. }
  1015.  
  1016.  
  1017. /**
  1018.  * Remap variables referenced in an instruction tree
  1019.  *
  1020.  * This is used when instruction trees are cloned from one shader and placed in
  1021.  * another.  These trees will contain references to \c ir_variable nodes that
  1022.  * do not exist in the target shader.  This function finds these \c ir_variable
  1023.  * references and replaces the references with matching variables in the target
  1024.  * shader.
  1025.  *
  1026.  * If there is no matching variable in the target shader, a clone of the
  1027.  * \c ir_variable is made and added to the target shader.  The new variable is
  1028.  * added to \b both the instruction stream and the symbol table.
  1029.  *
  1030.  * \param inst         IR tree that is to be processed.
  1031.  * \param symbols      Symbol table containing global scope symbols in the
  1032.  *                     linked shader.
  1033.  * \param instructions Instruction stream where new variable declarations
  1034.  *                     should be added.
  1035.  */
  1036. void
  1037. remap_variables(ir_instruction *inst, struct gl_shader *target,
  1038.                 hash_table *temps)
  1039. {
  1040.    class remap_visitor : public ir_hierarchical_visitor {
  1041.    public:
  1042.          remap_visitor(struct gl_shader *target,
  1043.                     hash_table *temps)
  1044.       {
  1045.          this->target = target;
  1046.          this->symbols = target->symbols;
  1047.          this->instructions = target->ir;
  1048.          this->temps = temps;
  1049.       }
  1050.  
  1051.       virtual ir_visitor_status visit(ir_dereference_variable *ir)
  1052.       {
  1053.          if (ir->var->data.mode == ir_var_temporary) {
  1054.             ir_variable *var = (ir_variable *) hash_table_find(temps, ir->var);
  1055.  
  1056.             assert(var != NULL);
  1057.             ir->var = var;
  1058.             return visit_continue;
  1059.          }
  1060.  
  1061.          ir_variable *const existing =
  1062.             this->symbols->get_variable(ir->var->name);
  1063.          if (existing != NULL)
  1064.             ir->var = existing;
  1065.          else {
  1066.             ir_variable *copy = ir->var->clone(this->target, NULL);
  1067.  
  1068.             this->symbols->add_variable(copy);
  1069.             this->instructions->push_head(copy);
  1070.             ir->var = copy;
  1071.          }
  1072.  
  1073.          return visit_continue;
  1074.       }
  1075.  
  1076.    private:
  1077.       struct gl_shader *target;
  1078.       glsl_symbol_table *symbols;
  1079.       exec_list *instructions;
  1080.       hash_table *temps;
  1081.    };
  1082.  
  1083.    remap_visitor v(target, temps);
  1084.  
  1085.    inst->accept(&v);
  1086. }
  1087.  
  1088.  
  1089. /**
  1090.  * Move non-declarations from one instruction stream to another
  1091.  *
  1092.  * The intended usage pattern of this function is to pass the pointer to the
  1093.  * head sentinel of a list (i.e., a pointer to the list cast to an \c exec_node
  1094.  * pointer) for \c last and \c false for \c make_copies on the first
  1095.  * call.  Successive calls pass the return value of the previous call for
  1096.  * \c last and \c true for \c make_copies.
  1097.  *
  1098.  * \param instructions Source instruction stream
  1099.  * \param last         Instruction after which new instructions should be
  1100.  *                     inserted in the target instruction stream
  1101.  * \param make_copies  Flag selecting whether instructions in \c instructions
  1102.  *                     should be copied (via \c ir_instruction::clone) into the
  1103.  *                     target list or moved.
  1104.  *
  1105.  * \return
  1106.  * The new "last" instruction in the target instruction stream.  This pointer
  1107.  * is suitable for use as the \c last parameter of a later call to this
  1108.  * function.
  1109.  */
  1110. exec_node *
  1111. move_non_declarations(exec_list *instructions, exec_node *last,
  1112.                       bool make_copies, gl_shader *target)
  1113. {
  1114.    hash_table *temps = NULL;
  1115.  
  1116.    if (make_copies)
  1117.       temps = hash_table_ctor(0, hash_table_pointer_hash,
  1118.                               hash_table_pointer_compare);
  1119.  
  1120.    foreach_in_list_safe(ir_instruction, inst, instructions) {
  1121.       if (inst->as_function())
  1122.          continue;
  1123.  
  1124.       ir_variable *var = inst->as_variable();
  1125.       if ((var != NULL) && (var->data.mode != ir_var_temporary))
  1126.          continue;
  1127.  
  1128.       assert(inst->as_assignment()
  1129.              || inst->as_call()
  1130.              || inst->as_if() /* for initializers with the ?: operator */
  1131.              || ((var != NULL) && (var->data.mode == ir_var_temporary)));
  1132.  
  1133.       if (make_copies) {
  1134.          inst = inst->clone(target, NULL);
  1135.  
  1136.          if (var != NULL)
  1137.             hash_table_insert(temps, inst, var);
  1138.          else
  1139.             remap_variables(inst, target, temps);
  1140.       } else {
  1141.          inst->remove();
  1142.       }
  1143.  
  1144.       last->insert_after(inst);
  1145.       last = inst;
  1146.    }
  1147.  
  1148.    if (make_copies)
  1149.       hash_table_dtor(temps);
  1150.  
  1151.    return last;
  1152. }
  1153.  
  1154. /**
  1155.  * Get the function signature for main from a shader
  1156.  */
  1157. ir_function_signature *
  1158. link_get_main_function_signature(gl_shader *sh)
  1159. {
  1160.    ir_function *const f = sh->symbols->get_function("main");
  1161.    if (f != NULL) {
  1162.       exec_list void_parameters;
  1163.  
  1164.       /* Look for the 'void main()' signature and ensure that it's defined.
  1165.        * This keeps the linker from accidentally pick a shader that just
  1166.        * contains a prototype for main.
  1167.        *
  1168.        * We don't have to check for multiple definitions of main (in multiple
  1169.        * shaders) because that would have already been caught above.
  1170.        */
  1171.       ir_function_signature *sig =
  1172.          f->matching_signature(NULL, &void_parameters, false);
  1173.       if ((sig != NULL) && sig->is_defined) {
  1174.          return sig;
  1175.       }
  1176.    }
  1177.  
  1178.    return NULL;
  1179. }
  1180.  
  1181.  
  1182. /**
  1183.  * This class is only used in link_intrastage_shaders() below but declaring
  1184.  * it inside that function leads to compiler warnings with some versions of
  1185.  * gcc.
  1186.  */
  1187. class array_sizing_visitor : public ir_hierarchical_visitor {
  1188. public:
  1189.    array_sizing_visitor()
  1190.       : mem_ctx(ralloc_context(NULL)),
  1191.         unnamed_interfaces(hash_table_ctor(0, hash_table_pointer_hash,
  1192.                                            hash_table_pointer_compare))
  1193.    {
  1194.    }
  1195.  
  1196.    ~array_sizing_visitor()
  1197.    {
  1198.       hash_table_dtor(this->unnamed_interfaces);
  1199.       ralloc_free(this->mem_ctx);
  1200.    }
  1201.  
  1202.    virtual ir_visitor_status visit(ir_variable *var)
  1203.    {
  1204.       fixup_type(&var->type, var->data.max_array_access);
  1205.       if (var->type->is_interface()) {
  1206.          if (interface_contains_unsized_arrays(var->type)) {
  1207.             const glsl_type *new_type =
  1208.                resize_interface_members(var->type,
  1209.                                         var->get_max_ifc_array_access());
  1210.             var->type = new_type;
  1211.             var->change_interface_type(new_type);
  1212.          }
  1213.       } else if (var->type->is_array() &&
  1214.                  var->type->fields.array->is_interface()) {
  1215.          if (interface_contains_unsized_arrays(var->type->fields.array)) {
  1216.             const glsl_type *new_type =
  1217.                resize_interface_members(var->type->fields.array,
  1218.                                         var->get_max_ifc_array_access());
  1219.             var->change_interface_type(new_type);
  1220.             var->type =
  1221.                glsl_type::get_array_instance(new_type, var->type->length);
  1222.          }
  1223.       } else if (const glsl_type *ifc_type = var->get_interface_type()) {
  1224.          /* Store a pointer to the variable in the unnamed_interfaces
  1225.           * hashtable.
  1226.           */
  1227.          ir_variable **interface_vars = (ir_variable **)
  1228.             hash_table_find(this->unnamed_interfaces, ifc_type);
  1229.          if (interface_vars == NULL) {
  1230.             interface_vars = rzalloc_array(mem_ctx, ir_variable *,
  1231.                                            ifc_type->length);
  1232.             hash_table_insert(this->unnamed_interfaces, interface_vars,
  1233.                               ifc_type);
  1234.          }
  1235.          unsigned index = ifc_type->field_index(var->name);
  1236.          assert(index < ifc_type->length);
  1237.          assert(interface_vars[index] == NULL);
  1238.          interface_vars[index] = var;
  1239.       }
  1240.       return visit_continue;
  1241.    }
  1242.  
  1243.    /**
  1244.     * For each unnamed interface block that was discovered while running the
  1245.     * visitor, adjust the interface type to reflect the newly assigned array
  1246.     * sizes, and fix up the ir_variable nodes to point to the new interface
  1247.     * type.
  1248.     */
  1249.    void fixup_unnamed_interface_types()
  1250.    {
  1251.       hash_table_call_foreach(this->unnamed_interfaces,
  1252.                               fixup_unnamed_interface_type, NULL);
  1253.    }
  1254.  
  1255. private:
  1256.    /**
  1257.     * If the type pointed to by \c type represents an unsized array, replace
  1258.     * it with a sized array whose size is determined by max_array_access.
  1259.     */
  1260.    static void fixup_type(const glsl_type **type, unsigned max_array_access)
  1261.    {
  1262.       if ((*type)->is_unsized_array()) {
  1263.          *type = glsl_type::get_array_instance((*type)->fields.array,
  1264.                                                max_array_access + 1);
  1265.          assert(*type != NULL);
  1266.       }
  1267.    }
  1268.  
  1269.    /**
  1270.     * Determine whether the given interface type contains unsized arrays (if
  1271.     * it doesn't, array_sizing_visitor doesn't need to process it).
  1272.     */
  1273.    static bool interface_contains_unsized_arrays(const glsl_type *type)
  1274.    {
  1275.       for (unsigned i = 0; i < type->length; i++) {
  1276.          const glsl_type *elem_type = type->fields.structure[i].type;
  1277.          if (elem_type->is_unsized_array())
  1278.             return true;
  1279.       }
  1280.       return false;
  1281.    }
  1282.  
  1283.    /**
  1284.     * Create a new interface type based on the given type, with unsized arrays
  1285.     * replaced by sized arrays whose size is determined by
  1286.     * max_ifc_array_access.
  1287.     */
  1288.    static const glsl_type *
  1289.    resize_interface_members(const glsl_type *type,
  1290.                             const unsigned *max_ifc_array_access)
  1291.    {
  1292.       unsigned num_fields = type->length;
  1293.       glsl_struct_field *fields = new glsl_struct_field[num_fields];
  1294.       memcpy(fields, type->fields.structure,
  1295.              num_fields * sizeof(*fields));
  1296.       for (unsigned i = 0; i < num_fields; i++) {
  1297.          fixup_type(&fields[i].type, max_ifc_array_access[i]);
  1298.       }
  1299.       glsl_interface_packing packing =
  1300.          (glsl_interface_packing) type->interface_packing;
  1301.       const glsl_type *new_ifc_type =
  1302.          glsl_type::get_interface_instance(fields, num_fields,
  1303.                                            packing, type->name);
  1304.       delete [] fields;
  1305.       return new_ifc_type;
  1306.    }
  1307.  
  1308.    static void fixup_unnamed_interface_type(const void *key, void *data,
  1309.                                             void *)
  1310.    {
  1311.       const glsl_type *ifc_type = (const glsl_type *) key;
  1312.       ir_variable **interface_vars = (ir_variable **) data;
  1313.       unsigned num_fields = ifc_type->length;
  1314.       glsl_struct_field *fields = new glsl_struct_field[num_fields];
  1315.       memcpy(fields, ifc_type->fields.structure,
  1316.              num_fields * sizeof(*fields));
  1317.       bool interface_type_changed = false;
  1318.       for (unsigned i = 0; i < num_fields; i++) {
  1319.          if (interface_vars[i] != NULL &&
  1320.              fields[i].type != interface_vars[i]->type) {
  1321.             fields[i].type = interface_vars[i]->type;
  1322.             interface_type_changed = true;
  1323.          }
  1324.       }
  1325.       if (!interface_type_changed) {
  1326.          delete [] fields;
  1327.          return;
  1328.       }
  1329.       glsl_interface_packing packing =
  1330.          (glsl_interface_packing) ifc_type->interface_packing;
  1331.       const glsl_type *new_ifc_type =
  1332.          glsl_type::get_interface_instance(fields, num_fields, packing,
  1333.                                            ifc_type->name);
  1334.       delete [] fields;
  1335.       for (unsigned i = 0; i < num_fields; i++) {
  1336.          if (interface_vars[i] != NULL)
  1337.             interface_vars[i]->change_interface_type(new_ifc_type);
  1338.       }
  1339.    }
  1340.  
  1341.    /**
  1342.     * Memory context used to allocate the data in \c unnamed_interfaces.
  1343.     */
  1344.    void *mem_ctx;
  1345.  
  1346.    /**
  1347.     * Hash table from const glsl_type * to an array of ir_variable *'s
  1348.     * pointing to the ir_variables constituting each unnamed interface block.
  1349.     */
  1350.    hash_table *unnamed_interfaces;
  1351. };
  1352.  
  1353. /**
  1354.  * Performs the cross-validation of layout qualifiers specified in
  1355.  * redeclaration of gl_FragCoord for the attached fragment shaders,
  1356.  * and propagates them to the linked FS and linked shader program.
  1357.  */
  1358. static void
  1359. link_fs_input_layout_qualifiers(struct gl_shader_program *prog,
  1360.                                 struct gl_shader *linked_shader,
  1361.                                 struct gl_shader **shader_list,
  1362.                                 unsigned num_shaders)
  1363. {
  1364.    linked_shader->redeclares_gl_fragcoord = false;
  1365.    linked_shader->uses_gl_fragcoord = false;
  1366.    linked_shader->origin_upper_left = false;
  1367.    linked_shader->pixel_center_integer = false;
  1368.  
  1369.    if (linked_shader->Stage != MESA_SHADER_FRAGMENT ||
  1370.        (prog->Version < 150 && !prog->ARB_fragment_coord_conventions_enable))
  1371.       return;
  1372.  
  1373.    for (unsigned i = 0; i < num_shaders; i++) {
  1374.       struct gl_shader *shader = shader_list[i];
  1375.       /* From the GLSL 1.50 spec, page 39:
  1376.        *
  1377.        *   "If gl_FragCoord is redeclared in any fragment shader in a program,
  1378.        *    it must be redeclared in all the fragment shaders in that program
  1379.        *    that have a static use gl_FragCoord."
  1380.        */
  1381.       if ((linked_shader->redeclares_gl_fragcoord
  1382.            && !shader->redeclares_gl_fragcoord
  1383.            && shader->uses_gl_fragcoord)
  1384.           || (shader->redeclares_gl_fragcoord
  1385.               && !linked_shader->redeclares_gl_fragcoord
  1386.               && linked_shader->uses_gl_fragcoord)) {
  1387.              linker_error(prog, "fragment shader defined with conflicting "
  1388.                          "layout qualifiers for gl_FragCoord\n");
  1389.       }
  1390.  
  1391.       /* From the GLSL 1.50 spec, page 39:
  1392.        *
  1393.        *   "All redeclarations of gl_FragCoord in all fragment shaders in a
  1394.        *    single program must have the same set of qualifiers."
  1395.        */
  1396.       if (linked_shader->redeclares_gl_fragcoord && shader->redeclares_gl_fragcoord
  1397.           && (shader->origin_upper_left != linked_shader->origin_upper_left
  1398.           || shader->pixel_center_integer != linked_shader->pixel_center_integer)) {
  1399.          linker_error(prog, "fragment shader defined with conflicting "
  1400.                       "layout qualifiers for gl_FragCoord\n");
  1401.       }
  1402.  
  1403.       /* Update the linked shader state.  Note that uses_gl_fragcoord should
  1404.        * accumulate the results.  The other values should replace.  If there
  1405.        * are multiple redeclarations, all the fields except uses_gl_fragcoord
  1406.        * are already known to be the same.
  1407.        */
  1408.       if (shader->redeclares_gl_fragcoord || shader->uses_gl_fragcoord) {
  1409.          linked_shader->redeclares_gl_fragcoord =
  1410.             shader->redeclares_gl_fragcoord;
  1411.          linked_shader->uses_gl_fragcoord = linked_shader->uses_gl_fragcoord
  1412.             || shader->uses_gl_fragcoord;
  1413.          linked_shader->origin_upper_left = shader->origin_upper_left;
  1414.          linked_shader->pixel_center_integer = shader->pixel_center_integer;
  1415.       }
  1416.  
  1417.       linked_shader->EarlyFragmentTests |= shader->EarlyFragmentTests;
  1418.    }
  1419. }
  1420.  
  1421. /**
  1422.  * Performs the cross-validation of geometry shader max_vertices and
  1423.  * primitive type layout qualifiers for the attached geometry shaders,
  1424.  * and propagates them to the linked GS and linked shader program.
  1425.  */
  1426. static void
  1427. link_gs_inout_layout_qualifiers(struct gl_shader_program *prog,
  1428.                                 struct gl_shader *linked_shader,
  1429.                                 struct gl_shader **shader_list,
  1430.                                 unsigned num_shaders)
  1431. {
  1432.    linked_shader->Geom.VerticesOut = 0;
  1433.    linked_shader->Geom.Invocations = 0;
  1434.    linked_shader->Geom.InputType = PRIM_UNKNOWN;
  1435.    linked_shader->Geom.OutputType = PRIM_UNKNOWN;
  1436.  
  1437.    /* No in/out qualifiers defined for anything but GLSL 1.50+
  1438.     * geometry shaders so far.
  1439.     */
  1440.    if (linked_shader->Stage != MESA_SHADER_GEOMETRY || prog->Version < 150)
  1441.       return;
  1442.  
  1443.    /* From the GLSL 1.50 spec, page 46:
  1444.     *
  1445.     *     "All geometry shader output layout declarations in a program
  1446.     *      must declare the same layout and same value for
  1447.     *      max_vertices. There must be at least one geometry output
  1448.     *      layout declaration somewhere in a program, but not all
  1449.     *      geometry shaders (compilation units) are required to
  1450.     *      declare it."
  1451.     */
  1452.  
  1453.    for (unsigned i = 0; i < num_shaders; i++) {
  1454.       struct gl_shader *shader = shader_list[i];
  1455.  
  1456.       if (shader->Geom.InputType != PRIM_UNKNOWN) {
  1457.          if (linked_shader->Geom.InputType != PRIM_UNKNOWN &&
  1458.              linked_shader->Geom.InputType != shader->Geom.InputType) {
  1459.             linker_error(prog, "geometry shader defined with conflicting "
  1460.                          "input types\n");
  1461.             return;
  1462.          }
  1463.          linked_shader->Geom.InputType = shader->Geom.InputType;
  1464.       }
  1465.  
  1466.       if (shader->Geom.OutputType != PRIM_UNKNOWN) {
  1467.          if (linked_shader->Geom.OutputType != PRIM_UNKNOWN &&
  1468.              linked_shader->Geom.OutputType != shader->Geom.OutputType) {
  1469.             linker_error(prog, "geometry shader defined with conflicting "
  1470.                          "output types\n");
  1471.             return;
  1472.          }
  1473.          linked_shader->Geom.OutputType = shader->Geom.OutputType;
  1474.       }
  1475.  
  1476.       if (shader->Geom.VerticesOut != 0) {
  1477.          if (linked_shader->Geom.VerticesOut != 0 &&
  1478.              linked_shader->Geom.VerticesOut != shader->Geom.VerticesOut) {
  1479.             linker_error(prog, "geometry shader defined with conflicting "
  1480.                          "output vertex count (%d and %d)\n",
  1481.                          linked_shader->Geom.VerticesOut,
  1482.                          shader->Geom.VerticesOut);
  1483.             return;
  1484.          }
  1485.          linked_shader->Geom.VerticesOut = shader->Geom.VerticesOut;
  1486.       }
  1487.  
  1488.       if (shader->Geom.Invocations != 0) {
  1489.          if (linked_shader->Geom.Invocations != 0 &&
  1490.              linked_shader->Geom.Invocations != shader->Geom.Invocations) {
  1491.             linker_error(prog, "geometry shader defined with conflicting "
  1492.                          "invocation count (%d and %d)\n",
  1493.                          linked_shader->Geom.Invocations,
  1494.                          shader->Geom.Invocations);
  1495.             return;
  1496.          }
  1497.          linked_shader->Geom.Invocations = shader->Geom.Invocations;
  1498.       }
  1499.    }
  1500.  
  1501.    /* Just do the intrastage -> interstage propagation right now,
  1502.     * since we already know we're in the right type of shader program
  1503.     * for doing it.
  1504.     */
  1505.    if (linked_shader->Geom.InputType == PRIM_UNKNOWN) {
  1506.       linker_error(prog,
  1507.                    "geometry shader didn't declare primitive input type\n");
  1508.       return;
  1509.    }
  1510.    prog->Geom.InputType = linked_shader->Geom.InputType;
  1511.  
  1512.    if (linked_shader->Geom.OutputType == PRIM_UNKNOWN) {
  1513.       linker_error(prog,
  1514.                    "geometry shader didn't declare primitive output type\n");
  1515.       return;
  1516.    }
  1517.    prog->Geom.OutputType = linked_shader->Geom.OutputType;
  1518.  
  1519.    if (linked_shader->Geom.VerticesOut == 0) {
  1520.       linker_error(prog,
  1521.                    "geometry shader didn't declare max_vertices\n");
  1522.       return;
  1523.    }
  1524.    prog->Geom.VerticesOut = linked_shader->Geom.VerticesOut;
  1525.  
  1526.    if (linked_shader->Geom.Invocations == 0)
  1527.       linked_shader->Geom.Invocations = 1;
  1528.  
  1529.    prog->Geom.Invocations = linked_shader->Geom.Invocations;
  1530. }
  1531.  
  1532.  
  1533. /**
  1534.  * Perform cross-validation of compute shader local_size_{x,y,z} layout
  1535.  * qualifiers for the attached compute shaders, and propagate them to the
  1536.  * linked CS and linked shader program.
  1537.  */
  1538. static void
  1539. link_cs_input_layout_qualifiers(struct gl_shader_program *prog,
  1540.                                 struct gl_shader *linked_shader,
  1541.                                 struct gl_shader **shader_list,
  1542.                                 unsigned num_shaders)
  1543. {
  1544.    for (int i = 0; i < 3; i++)
  1545.       linked_shader->Comp.LocalSize[i] = 0;
  1546.  
  1547.    /* This function is called for all shader stages, but it only has an effect
  1548.     * for compute shaders.
  1549.     */
  1550.    if (linked_shader->Stage != MESA_SHADER_COMPUTE)
  1551.       return;
  1552.  
  1553.    /* From the ARB_compute_shader spec, in the section describing local size
  1554.     * declarations:
  1555.     *
  1556.     *     If multiple compute shaders attached to a single program object
  1557.     *     declare local work-group size, the declarations must be identical;
  1558.     *     otherwise a link-time error results. Furthermore, if a program
  1559.     *     object contains any compute shaders, at least one must contain an
  1560.     *     input layout qualifier specifying the local work sizes of the
  1561.     *     program, or a link-time error will occur.
  1562.     */
  1563.    for (unsigned sh = 0; sh < num_shaders; sh++) {
  1564.       struct gl_shader *shader = shader_list[sh];
  1565.  
  1566.       if (shader->Comp.LocalSize[0] != 0) {
  1567.          if (linked_shader->Comp.LocalSize[0] != 0) {
  1568.             for (int i = 0; i < 3; i++) {
  1569.                if (linked_shader->Comp.LocalSize[i] !=
  1570.                    shader->Comp.LocalSize[i]) {
  1571.                   linker_error(prog, "compute shader defined with conflicting "
  1572.                                "local sizes\n");
  1573.                   return;
  1574.                }
  1575.             }
  1576.          }
  1577.          for (int i = 0; i < 3; i++)
  1578.             linked_shader->Comp.LocalSize[i] = shader->Comp.LocalSize[i];
  1579.       }
  1580.    }
  1581.  
  1582.    /* Just do the intrastage -> interstage propagation right now,
  1583.     * since we already know we're in the right type of shader program
  1584.     * for doing it.
  1585.     */
  1586.    if (linked_shader->Comp.LocalSize[0] == 0) {
  1587.       linker_error(prog, "compute shader didn't declare local size\n");
  1588.       return;
  1589.    }
  1590.    for (int i = 0; i < 3; i++)
  1591.       prog->Comp.LocalSize[i] = linked_shader->Comp.LocalSize[i];
  1592. }
  1593.  
  1594.  
  1595. /**
  1596.  * Combine a group of shaders for a single stage to generate a linked shader
  1597.  *
  1598.  * \note
  1599.  * If this function is supplied a single shader, it is cloned, and the new
  1600.  * shader is returned.
  1601.  */
  1602. static struct gl_shader *
  1603. link_intrastage_shaders(void *mem_ctx,
  1604.                         struct gl_context *ctx,
  1605.                         struct gl_shader_program *prog,
  1606.                         struct gl_shader **shader_list,
  1607.                         unsigned num_shaders)
  1608. {
  1609.    struct gl_uniform_block *uniform_blocks = NULL;
  1610.  
  1611.    /* Check that global variables defined in multiple shaders are consistent.
  1612.     */
  1613.    cross_validate_globals(prog, shader_list, num_shaders, false);
  1614.    if (!prog->LinkStatus)
  1615.       return NULL;
  1616.  
  1617.    /* Check that interface blocks defined in multiple shaders are consistent.
  1618.     */
  1619.    validate_intrastage_interface_blocks(prog, (const gl_shader **)shader_list,
  1620.                                         num_shaders);
  1621.    if (!prog->LinkStatus)
  1622.       return NULL;
  1623.  
  1624.    /* Link up uniform blocks defined within this stage. */
  1625.    const unsigned num_uniform_blocks =
  1626.       link_uniform_blocks(mem_ctx, prog, shader_list, num_shaders,
  1627.                           &uniform_blocks);
  1628.    if (!prog->LinkStatus)
  1629.       return NULL;
  1630.  
  1631.    /* Check that there is only a single definition of each function signature
  1632.     * across all shaders.
  1633.     */
  1634.    for (unsigned i = 0; i < (num_shaders - 1); i++) {
  1635.       foreach_in_list(ir_instruction, node, shader_list[i]->ir) {
  1636.          ir_function *const f = node->as_function();
  1637.  
  1638.          if (f == NULL)
  1639.             continue;
  1640.  
  1641.          for (unsigned j = i + 1; j < num_shaders; j++) {
  1642.             ir_function *const other =
  1643.                shader_list[j]->symbols->get_function(f->name);
  1644.  
  1645.             /* If the other shader has no function (and therefore no function
  1646.              * signatures) with the same name, skip to the next shader.
  1647.              */
  1648.             if (other == NULL)
  1649.                continue;
  1650.  
  1651.             foreach_in_list(ir_function_signature, sig, &f->signatures) {
  1652.                if (!sig->is_defined || sig->is_builtin())
  1653.                   continue;
  1654.  
  1655.                ir_function_signature *other_sig =
  1656.                   other->exact_matching_signature(NULL, &sig->parameters);
  1657.  
  1658.                if ((other_sig != NULL) && other_sig->is_defined
  1659.                    && !other_sig->is_builtin()) {
  1660.                   linker_error(prog, "function `%s' is multiply defined\n",
  1661.                                f->name);
  1662.                   return NULL;
  1663.                }
  1664.             }
  1665.          }
  1666.       }
  1667.    }
  1668.  
  1669.    /* Find the shader that defines main, and make a clone of it.
  1670.     *
  1671.     * Starting with the clone, search for undefined references.  If one is
  1672.     * found, find the shader that defines it.  Clone the reference and add
  1673.     * it to the shader.  Repeat until there are no undefined references or
  1674.     * until a reference cannot be resolved.
  1675.     */
  1676.    gl_shader *main = NULL;
  1677.    for (unsigned i = 0; i < num_shaders; i++) {
  1678.       if (link_get_main_function_signature(shader_list[i]) != NULL) {
  1679.          main = shader_list[i];
  1680.          break;
  1681.       }
  1682.    }
  1683.  
  1684.    if (main == NULL) {
  1685.       linker_error(prog, "%s shader lacks `main'\n",
  1686.                    _mesa_shader_stage_to_string(shader_list[0]->Stage));
  1687.       return NULL;
  1688.    }
  1689.  
  1690.    gl_shader *linked = ctx->Driver.NewShader(NULL, 0, main->Type);
  1691.    linked->ir = new(linked) exec_list;
  1692.    clone_ir_list(mem_ctx, linked->ir, main->ir);
  1693.  
  1694.    linked->UniformBlocks = uniform_blocks;
  1695.    linked->NumUniformBlocks = num_uniform_blocks;
  1696.    ralloc_steal(linked, linked->UniformBlocks);
  1697.  
  1698.    link_fs_input_layout_qualifiers(prog, linked, shader_list, num_shaders);
  1699.    link_gs_inout_layout_qualifiers(prog, linked, shader_list, num_shaders);
  1700.    link_cs_input_layout_qualifiers(prog, linked, shader_list, num_shaders);
  1701.  
  1702.    populate_symbol_table(linked);
  1703.  
  1704.    /* The pointer to the main function in the final linked shader (i.e., the
  1705.     * copy of the original shader that contained the main function).
  1706.     */
  1707.    ir_function_signature *const main_sig =
  1708.       link_get_main_function_signature(linked);
  1709.  
  1710.    /* Move any instructions other than variable declarations or function
  1711.     * declarations into main.
  1712.     */
  1713.    exec_node *insertion_point =
  1714.       move_non_declarations(linked->ir, (exec_node *) &main_sig->body, false,
  1715.                             linked);
  1716.  
  1717.    for (unsigned i = 0; i < num_shaders; i++) {
  1718.       if (shader_list[i] == main)
  1719.          continue;
  1720.  
  1721.       insertion_point = move_non_declarations(shader_list[i]->ir,
  1722.                                               insertion_point, true, linked);
  1723.    }
  1724.  
  1725.    /* Check if any shader needs built-in functions. */
  1726.    bool need_builtins = false;
  1727.    for (unsigned i = 0; i < num_shaders; i++) {
  1728.       if (shader_list[i]->uses_builtin_functions) {
  1729.          need_builtins = true;
  1730.          break;
  1731.       }
  1732.    }
  1733.  
  1734.    bool ok;
  1735.    if (need_builtins) {
  1736.       /* Make a temporary array one larger than shader_list, which will hold
  1737.        * the built-in function shader as well.
  1738.        */
  1739.       gl_shader **linking_shaders = (gl_shader **)
  1740.          calloc(num_shaders + 1, sizeof(gl_shader *));
  1741.  
  1742.       ok = linking_shaders != NULL;
  1743.  
  1744.       if (ok) {
  1745.          memcpy(linking_shaders, shader_list, num_shaders * sizeof(gl_shader *));
  1746.          linking_shaders[num_shaders] = _mesa_glsl_get_builtin_function_shader();
  1747.  
  1748.          ok = link_function_calls(prog, linked, linking_shaders, num_shaders + 1);
  1749.  
  1750.          free(linking_shaders);
  1751.       } else {
  1752.          _mesa_error_no_memory(__func__);
  1753.       }
  1754.    } else {
  1755.       ok = link_function_calls(prog, linked, shader_list, num_shaders);
  1756.    }
  1757.  
  1758.  
  1759.    if (!ok) {
  1760.       ctx->Driver.DeleteShader(ctx, linked);
  1761.       return NULL;
  1762.    }
  1763.  
  1764.    /* At this point linked should contain all of the linked IR, so
  1765.     * validate it to make sure nothing went wrong.
  1766.     */
  1767.    validate_ir_tree(linked->ir);
  1768.  
  1769.    /* Set the size of geometry shader input arrays */
  1770.    if (linked->Stage == MESA_SHADER_GEOMETRY) {
  1771.       unsigned num_vertices = vertices_per_prim(prog->Geom.InputType);
  1772.       geom_array_resize_visitor input_resize_visitor(num_vertices, prog);
  1773.       foreach_in_list(ir_instruction, ir, linked->ir) {
  1774.          ir->accept(&input_resize_visitor);
  1775.       }
  1776.    }
  1777.  
  1778.    if (ctx->Const.VertexID_is_zero_based)
  1779.       lower_vertex_id(linked);
  1780.  
  1781.    /* Make a pass over all variable declarations to ensure that arrays with
  1782.     * unspecified sizes have a size specified.  The size is inferred from the
  1783.     * max_array_access field.
  1784.     */
  1785.    array_sizing_visitor v;
  1786.    v.run(linked->ir);
  1787.    v.fixup_unnamed_interface_types();
  1788.  
  1789.    return linked;
  1790. }
  1791.  
  1792. /**
  1793.  * Update the sizes of linked shader uniform arrays to the maximum
  1794.  * array index used.
  1795.  *
  1796.  * From page 81 (page 95 of the PDF) of the OpenGL 2.1 spec:
  1797.  *
  1798.  *     If one or more elements of an array are active,
  1799.  *     GetActiveUniform will return the name of the array in name,
  1800.  *     subject to the restrictions listed above. The type of the array
  1801.  *     is returned in type. The size parameter contains the highest
  1802.  *     array element index used, plus one. The compiler or linker
  1803.  *     determines the highest index used.  There will be only one
  1804.  *     active uniform reported by the GL per uniform array.
  1805.  
  1806.  */
  1807. static void
  1808. update_array_sizes(struct gl_shader_program *prog)
  1809. {
  1810.    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  1811.          if (prog->_LinkedShaders[i] == NULL)
  1812.             continue;
  1813.  
  1814.       foreach_in_list(ir_instruction, node, prog->_LinkedShaders[i]->ir) {
  1815.          ir_variable *const var = node->as_variable();
  1816.  
  1817.          if ((var == NULL) || (var->data.mode != ir_var_uniform) ||
  1818.              !var->type->is_array())
  1819.             continue;
  1820.  
  1821.          /* GL_ARB_uniform_buffer_object says that std140 uniforms
  1822.           * will not be eliminated.  Since we always do std140, just
  1823.           * don't resize arrays in UBOs.
  1824.           *
  1825.           * Atomic counters are supposed to get deterministic
  1826.           * locations assigned based on the declaration ordering and
  1827.           * sizes, array compaction would mess that up.
  1828.           */
  1829.          if (var->is_in_uniform_block() || var->type->contains_atomic())
  1830.             continue;
  1831.  
  1832.          unsigned int size = var->data.max_array_access;
  1833.          for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
  1834.                if (prog->_LinkedShaders[j] == NULL)
  1835.                   continue;
  1836.  
  1837.             foreach_in_list(ir_instruction, node2, prog->_LinkedShaders[j]->ir) {
  1838.                ir_variable *other_var = node2->as_variable();
  1839.                if (!other_var)
  1840.                   continue;
  1841.  
  1842.                if (strcmp(var->name, other_var->name) == 0 &&
  1843.                    other_var->data.max_array_access > size) {
  1844.                   size = other_var->data.max_array_access;
  1845.                }
  1846.             }
  1847.          }
  1848.  
  1849.          if (size + 1 != var->type->length) {
  1850.             /* If this is a built-in uniform (i.e., it's backed by some
  1851.              * fixed-function state), adjust the number of state slots to
  1852.              * match the new array size.  The number of slots per array entry
  1853.              * is not known.  It seems safe to assume that the total number of
  1854.              * slots is an integer multiple of the number of array elements.
  1855.              * Determine the number of slots per array element by dividing by
  1856.              * the old (total) size.
  1857.              */
  1858.             const unsigned num_slots = var->get_num_state_slots();
  1859.             if (num_slots > 0) {
  1860.                var->set_num_state_slots((size + 1)
  1861.                                         * (num_slots / var->type->length));
  1862.             }
  1863.  
  1864.             var->type = glsl_type::get_array_instance(var->type->fields.array,
  1865.                                                       size + 1);
  1866.             /* FINISHME: We should update the types of array
  1867.              * dereferences of this variable now.
  1868.              */
  1869.          }
  1870.       }
  1871.    }
  1872. }
  1873.  
  1874. /**
  1875.  * Find a contiguous set of available bits in a bitmask.
  1876.  *
  1877.  * \param used_mask     Bits representing used (1) and unused (0) locations
  1878.  * \param needed_count  Number of contiguous bits needed.
  1879.  *
  1880.  * \return
  1881.  * Base location of the available bits on success or -1 on failure.
  1882.  */
  1883. int
  1884. find_available_slots(unsigned used_mask, unsigned needed_count)
  1885. {
  1886.    unsigned needed_mask = (1 << needed_count) - 1;
  1887.    const int max_bit_to_test = (8 * sizeof(used_mask)) - needed_count;
  1888.  
  1889.    /* The comparison to 32 is redundant, but without it GCC emits "warning:
  1890.     * cannot optimize possibly infinite loops" for the loop below.
  1891.     */
  1892.    if ((needed_count == 0) || (max_bit_to_test < 0) || (max_bit_to_test > 32))
  1893.       return -1;
  1894.  
  1895.    for (int i = 0; i <= max_bit_to_test; i++) {
  1896.       if ((needed_mask & ~used_mask) == needed_mask)
  1897.          return i;
  1898.  
  1899.       needed_mask <<= 1;
  1900.    }
  1901.  
  1902.    return -1;
  1903. }
  1904.  
  1905.  
  1906. /**
  1907.  * Assign locations for either VS inputs or FS outputs
  1908.  *
  1909.  * \param prog          Shader program whose variables need locations assigned
  1910.  * \param target_index  Selector for the program target to receive location
  1911.  *                      assignmnets.  Must be either \c MESA_SHADER_VERTEX or
  1912.  *                      \c MESA_SHADER_FRAGMENT.
  1913.  * \param max_index     Maximum number of generic locations.  This corresponds
  1914.  *                      to either the maximum number of draw buffers or the
  1915.  *                      maximum number of generic attributes.
  1916.  *
  1917.  * \return
  1918.  * If locations are successfully assigned, true is returned.  Otherwise an
  1919.  * error is emitted to the shader link log and false is returned.
  1920.  */
  1921. bool
  1922. assign_attribute_or_color_locations(gl_shader_program *prog,
  1923.                                     unsigned target_index,
  1924.                                     unsigned max_index)
  1925. {
  1926.    /* Mark invalid locations as being used.
  1927.     */
  1928.    unsigned used_locations = (max_index >= 32)
  1929.       ? ~0 : ~((1 << max_index) - 1);
  1930.  
  1931.    assert((target_index == MESA_SHADER_VERTEX)
  1932.           || (target_index == MESA_SHADER_FRAGMENT));
  1933.  
  1934.    gl_shader *const sh = prog->_LinkedShaders[target_index];
  1935.    if (sh == NULL)
  1936.       return true;
  1937.  
  1938.    /* Operate in a total of four passes.
  1939.     *
  1940.     * 1. Invalidate the location assignments for all vertex shader inputs.
  1941.     *
  1942.     * 2. Assign locations for inputs that have user-defined (via
  1943.     *    glBindVertexAttribLocation) locations and outputs that have
  1944.     *    user-defined locations (via glBindFragDataLocation).
  1945.     *
  1946.     * 3. Sort the attributes without assigned locations by number of slots
  1947.     *    required in decreasing order.  Fragmentation caused by attribute
  1948.     *    locations assigned by the application may prevent large attributes
  1949.     *    from having enough contiguous space.
  1950.     *
  1951.     * 4. Assign locations to any inputs without assigned locations.
  1952.     */
  1953.  
  1954.    const int generic_base = (target_index == MESA_SHADER_VERTEX)
  1955.       ? (int) VERT_ATTRIB_GENERIC0 : (int) FRAG_RESULT_DATA0;
  1956.  
  1957.    const enum ir_variable_mode direction =
  1958.       (target_index == MESA_SHADER_VERTEX)
  1959.       ? ir_var_shader_in : ir_var_shader_out;
  1960.  
  1961.  
  1962.    /* Temporary storage for the set of attributes that need locations assigned.
  1963.     */
  1964.    struct temp_attr {
  1965.       unsigned slots;
  1966.       ir_variable *var;
  1967.  
  1968.       /* Used below in the call to qsort. */
  1969.       static int compare(const void *a, const void *b)
  1970.       {
  1971.          const temp_attr *const l = (const temp_attr *) a;
  1972.          const temp_attr *const r = (const temp_attr *) b;
  1973.  
  1974.          /* Reversed because we want a descending order sort below. */
  1975.          return r->slots - l->slots;
  1976.       }
  1977.    } to_assign[16];
  1978.  
  1979.    unsigned num_attr = 0;
  1980.    unsigned total_attribs_size = 0;
  1981.  
  1982.    foreach_in_list(ir_instruction, node, sh->ir) {
  1983.       ir_variable *const var = node->as_variable();
  1984.  
  1985.       if ((var == NULL) || (var->data.mode != (unsigned) direction))
  1986.          continue;
  1987.  
  1988.       if (var->data.explicit_location) {
  1989.          if ((var->data.location >= (int)(max_index + generic_base))
  1990.              || (var->data.location < 0)) {
  1991.             linker_error(prog,
  1992.                          "invalid explicit location %d specified for `%s'\n",
  1993.                          (var->data.location < 0)
  1994.                          ? var->data.location
  1995.                          : var->data.location - generic_base,
  1996.                          var->name);
  1997.             return false;
  1998.          }
  1999.       } else if (target_index == MESA_SHADER_VERTEX) {
  2000.          unsigned binding;
  2001.  
  2002.          if (prog->AttributeBindings->get(binding, var->name)) {
  2003.             assert(binding >= VERT_ATTRIB_GENERIC0);
  2004.             var->data.location = binding;
  2005.             var->data.is_unmatched_generic_inout = 0;
  2006.          }
  2007.       } else if (target_index == MESA_SHADER_FRAGMENT) {
  2008.          unsigned binding;
  2009.          unsigned index;
  2010.  
  2011.          if (prog->FragDataBindings->get(binding, var->name)) {
  2012.             assert(binding >= FRAG_RESULT_DATA0);
  2013.             var->data.location = binding;
  2014.             var->data.is_unmatched_generic_inout = 0;
  2015.  
  2016.             if (prog->FragDataIndexBindings->get(index, var->name)) {
  2017.                var->data.index = index;
  2018.             }
  2019.          }
  2020.       }
  2021.  
  2022.       const unsigned slots = var->type->count_attribute_slots();
  2023.  
  2024.       /* From GL4.5 core spec, section 11.1.1 (Vertex Attributes):
  2025.        *
  2026.        * "A program with more than the value of MAX_VERTEX_ATTRIBS active
  2027.        * attribute variables may fail to link, unless device-dependent
  2028.        * optimizations are able to make the program fit within available
  2029.        * hardware resources. For the purposes of this test, attribute variables
  2030.        * of the type dvec3, dvec4, dmat2x3, dmat2x4, dmat3, dmat3x4, dmat4x3,
  2031.        * and dmat4 may count as consuming twice as many attributes as equivalent
  2032.        * single-precision types. While these types use the same number of
  2033.        * generic attributes as their single-precision equivalents,
  2034.        * implementations are permitted to consume two single-precision vectors
  2035.        * of internal storage for each three- or four-component double-precision
  2036.        * vector."
  2037.        * Until someone has a good reason in Mesa, enforce that now.
  2038.        */
  2039.       if (target_index == MESA_SHADER_VERTEX) {
  2040.          total_attribs_size += slots;
  2041.          if (var->type->without_array() == glsl_type::dvec3_type ||
  2042.              var->type->without_array() == glsl_type::dvec4_type ||
  2043.              var->type->without_array() == glsl_type::dmat2x3_type ||
  2044.              var->type->without_array() == glsl_type::dmat2x4_type ||
  2045.              var->type->without_array() == glsl_type::dmat3_type ||
  2046.              var->type->without_array() == glsl_type::dmat3x4_type ||
  2047.              var->type->without_array() == glsl_type::dmat4x3_type ||
  2048.              var->type->without_array() == glsl_type::dmat4_type)
  2049.             total_attribs_size += slots;
  2050.       }
  2051.  
  2052.       /* If the variable is not a built-in and has a location statically
  2053.        * assigned in the shader (presumably via a layout qualifier), make sure
  2054.        * that it doesn't collide with other assigned locations.  Otherwise,
  2055.        * add it to the list of variables that need linker-assigned locations.
  2056.        */
  2057.       if (var->data.location != -1) {
  2058.          if (var->data.location >= generic_base && var->data.index < 1) {
  2059.             /* From page 61 of the OpenGL 4.0 spec:
  2060.              *
  2061.              *     "LinkProgram will fail if the attribute bindings assigned
  2062.              *     by BindAttribLocation do not leave not enough space to
  2063.              *     assign a location for an active matrix attribute or an
  2064.              *     active attribute array, both of which require multiple
  2065.              *     contiguous generic attributes."
  2066.              *
  2067.              * I think above text prohibits the aliasing of explicit and
  2068.              * automatic assignments. But, aliasing is allowed in manual
  2069.              * assignments of attribute locations. See below comments for
  2070.              * the details.
  2071.              *
  2072.              * From OpenGL 4.0 spec, page 61:
  2073.              *
  2074.              *     "It is possible for an application to bind more than one
  2075.              *     attribute name to the same location. This is referred to as
  2076.              *     aliasing. This will only work if only one of the aliased
  2077.              *     attributes is active in the executable program, or if no
  2078.              *     path through the shader consumes more than one attribute of
  2079.              *     a set of attributes aliased to the same location. A link
  2080.              *     error can occur if the linker determines that every path
  2081.              *     through the shader consumes multiple aliased attributes,
  2082.              *     but implementations are not required to generate an error
  2083.              *     in this case."
  2084.              *
  2085.              * From GLSL 4.30 spec, page 54:
  2086.              *
  2087.              *    "A program will fail to link if any two non-vertex shader
  2088.              *     input variables are assigned to the same location. For
  2089.              *     vertex shaders, multiple input variables may be assigned
  2090.              *     to the same location using either layout qualifiers or via
  2091.              *     the OpenGL API. However, such aliasing is intended only to
  2092.              *     support vertex shaders where each execution path accesses
  2093.              *     at most one input per each location. Implementations are
  2094.              *     permitted, but not required, to generate link-time errors
  2095.              *     if they detect that every path through the vertex shader
  2096.              *     executable accesses multiple inputs assigned to any single
  2097.              *     location. For all shader types, a program will fail to link
  2098.              *     if explicit location assignments leave the linker unable
  2099.              *     to find space for other variables without explicit
  2100.              *     assignments."
  2101.              *
  2102.              * From OpenGL ES 3.0 spec, page 56:
  2103.              *
  2104.              *    "Binding more than one attribute name to the same location
  2105.              *     is referred to as aliasing, and is not permitted in OpenGL
  2106.              *     ES Shading Language 3.00 vertex shaders. LinkProgram will
  2107.              *     fail when this condition exists. However, aliasing is
  2108.              *     possible in OpenGL ES Shading Language 1.00 vertex shaders.
  2109.              *     This will only work if only one of the aliased attributes
  2110.              *     is active in the executable program, or if no path through
  2111.              *     the shader consumes more than one attribute of a set of
  2112.              *     attributes aliased to the same location. A link error can
  2113.              *     occur if the linker determines that every path through the
  2114.              *     shader consumes multiple aliased attributes, but implemen-
  2115.              *     tations are not required to generate an error in this case."
  2116.              *
  2117.              * After looking at above references from OpenGL, OpenGL ES and
  2118.              * GLSL specifications, we allow aliasing of vertex input variables
  2119.              * in: OpenGL 2.0 (and above) and OpenGL ES 2.0.
  2120.              *
  2121.              * NOTE: This is not required by the spec but its worth mentioning
  2122.              * here that we're not doing anything to make sure that no path
  2123.              * through the vertex shader executable accesses multiple inputs
  2124.              * assigned to any single location.
  2125.              */
  2126.  
  2127.             /* Mask representing the contiguous slots that will be used by
  2128.              * this attribute.
  2129.              */
  2130.             const unsigned attr = var->data.location - generic_base;
  2131.             const unsigned use_mask = (1 << slots) - 1;
  2132.             const char *const string = (target_index == MESA_SHADER_VERTEX)
  2133.                ? "vertex shader input" : "fragment shader output";
  2134.  
  2135.             /* Generate a link error if the requested locations for this
  2136.              * attribute exceed the maximum allowed attribute location.
  2137.              */
  2138.             if (attr + slots > max_index) {
  2139.                linker_error(prog,
  2140.                            "insufficient contiguous locations "
  2141.                            "available for %s `%s' %d %d %d\n", string,
  2142.                            var->name, used_locations, use_mask, attr);
  2143.                return false;
  2144.             }
  2145.  
  2146.             /* Generate a link error if the set of bits requested for this
  2147.              * attribute overlaps any previously allocated bits.
  2148.              */
  2149.             if ((~(use_mask << attr) & used_locations) != used_locations) {
  2150.                if (target_index == MESA_SHADER_FRAGMENT ||
  2151.                    (prog->IsES && prog->Version >= 300)) {
  2152.                   linker_error(prog,
  2153.                                "overlapping location is assigned "
  2154.                                "to %s `%s' %d %d %d\n", string,
  2155.                                var->name, used_locations, use_mask, attr);
  2156.                   return false;
  2157.                } else {
  2158.                   linker_warning(prog,
  2159.                                  "overlapping location is assigned "
  2160.                                  "to %s `%s' %d %d %d\n", string,
  2161.                                  var->name, used_locations, use_mask, attr);
  2162.                }
  2163.             }
  2164.  
  2165.             used_locations |= (use_mask << attr);
  2166.          }
  2167.  
  2168.          continue;
  2169.       }
  2170.  
  2171.       to_assign[num_attr].slots = slots;
  2172.       to_assign[num_attr].var = var;
  2173.       num_attr++;
  2174.    }
  2175.  
  2176.    if (target_index == MESA_SHADER_VERTEX) {
  2177.       if (total_attribs_size > max_index) {
  2178.          linker_error(prog,
  2179.                       "attempt to use %d vertex attribute slots only %d available ",
  2180.                       total_attribs_size, max_index);
  2181.          return false;
  2182.       }
  2183.    }
  2184.  
  2185.    /* If all of the attributes were assigned locations by the application (or
  2186.     * are built-in attributes with fixed locations), return early.  This should
  2187.     * be the common case.
  2188.     */
  2189.    if (num_attr == 0)
  2190.       return true;
  2191.  
  2192.    qsort(to_assign, num_attr, sizeof(to_assign[0]), temp_attr::compare);
  2193.  
  2194.    if (target_index == MESA_SHADER_VERTEX) {
  2195.       /* VERT_ATTRIB_GENERIC0 is a pseudo-alias for VERT_ATTRIB_POS.  It can
  2196.        * only be explicitly assigned by via glBindAttribLocation.  Mark it as
  2197.        * reserved to prevent it from being automatically allocated below.
  2198.        */
  2199.       find_deref_visitor find("gl_Vertex");
  2200.       find.run(sh->ir);
  2201.       if (find.variable_found())
  2202.          used_locations |= (1 << 0);
  2203.    }
  2204.  
  2205.    for (unsigned i = 0; i < num_attr; i++) {
  2206.       /* Mask representing the contiguous slots that will be used by this
  2207.        * attribute.
  2208.        */
  2209.       const unsigned use_mask = (1 << to_assign[i].slots) - 1;
  2210.  
  2211.       int location = find_available_slots(used_locations, to_assign[i].slots);
  2212.  
  2213.       if (location < 0) {
  2214.          const char *const string = (target_index == MESA_SHADER_VERTEX)
  2215.             ? "vertex shader input" : "fragment shader output";
  2216.  
  2217.          linker_error(prog,
  2218.                       "insufficient contiguous locations "
  2219.                       "available for %s `%s'\n",
  2220.                       string, to_assign[i].var->name);
  2221.          return false;
  2222.       }
  2223.  
  2224.       to_assign[i].var->data.location = generic_base + location;
  2225.       to_assign[i].var->data.is_unmatched_generic_inout = 0;
  2226.       used_locations |= (use_mask << location);
  2227.    }
  2228.  
  2229.    return true;
  2230. }
  2231.  
  2232.  
  2233. /**
  2234.  * Demote shader inputs and outputs that are not used in other stages
  2235.  */
  2236. void
  2237. demote_shader_inputs_and_outputs(gl_shader *sh, enum ir_variable_mode mode)
  2238. {
  2239.    foreach_in_list(ir_instruction, node, sh->ir) {
  2240.       ir_variable *const var = node->as_variable();
  2241.  
  2242.       if ((var == NULL) || (var->data.mode != int(mode)))
  2243.          continue;
  2244.  
  2245.       /* A shader 'in' or 'out' variable is only really an input or output if
  2246.        * its value is used by other shader stages.  This will cause the variable
  2247.        * to have a location assigned.
  2248.        */
  2249.       if (var->data.is_unmatched_generic_inout) {
  2250.          assert(var->data.mode != ir_var_temporary);
  2251.          var->data.mode = ir_var_auto;
  2252.       }
  2253.    }
  2254. }
  2255.  
  2256.  
  2257. /**
  2258.  * Store the gl_FragDepth layout in the gl_shader_program struct.
  2259.  */
  2260. static void
  2261. store_fragdepth_layout(struct gl_shader_program *prog)
  2262. {
  2263.    if (prog->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL) {
  2264.       return;
  2265.    }
  2266.  
  2267.    struct exec_list *ir = prog->_LinkedShaders[MESA_SHADER_FRAGMENT]->ir;
  2268.  
  2269.    /* We don't look up the gl_FragDepth symbol directly because if
  2270.     * gl_FragDepth is not used in the shader, it's removed from the IR.
  2271.     * However, the symbol won't be removed from the symbol table.
  2272.     *
  2273.     * We're only interested in the cases where the variable is NOT removed
  2274.     * from the IR.
  2275.     */
  2276.    foreach_in_list(ir_instruction, node, ir) {
  2277.       ir_variable *const var = node->as_variable();
  2278.  
  2279.       if (var == NULL || var->data.mode != ir_var_shader_out) {
  2280.          continue;
  2281.       }
  2282.  
  2283.       if (strcmp(var->name, "gl_FragDepth") == 0) {
  2284.          switch (var->data.depth_layout) {
  2285.          case ir_depth_layout_none:
  2286.             prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_NONE;
  2287.             return;
  2288.          case ir_depth_layout_any:
  2289.             prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_ANY;
  2290.             return;
  2291.          case ir_depth_layout_greater:
  2292.             prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_GREATER;
  2293.             return;
  2294.          case ir_depth_layout_less:
  2295.             prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_LESS;
  2296.             return;
  2297.          case ir_depth_layout_unchanged:
  2298.             prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_UNCHANGED;
  2299.             return;
  2300.          default:
  2301.             assert(0);
  2302.             return;
  2303.          }
  2304.       }
  2305.    }
  2306. }
  2307.  
  2308. /**
  2309.  * Validate the resources used by a program versus the implementation limits
  2310.  */
  2311. static void
  2312. check_resources(struct gl_context *ctx, struct gl_shader_program *prog)
  2313. {
  2314.    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  2315.       struct gl_shader *sh = prog->_LinkedShaders[i];
  2316.  
  2317.       if (sh == NULL)
  2318.          continue;
  2319.  
  2320.       if (sh->num_samplers > ctx->Const.Program[i].MaxTextureImageUnits) {
  2321.          linker_error(prog, "Too many %s shader texture samplers\n",
  2322.                       _mesa_shader_stage_to_string(i));
  2323.       }
  2324.  
  2325.       if (sh->num_uniform_components >
  2326.           ctx->Const.Program[i].MaxUniformComponents) {
  2327.          if (ctx->Const.GLSLSkipStrictMaxUniformLimitCheck) {
  2328.             linker_warning(prog, "Too many %s shader default uniform block "
  2329.                            "components, but the driver will try to optimize "
  2330.                            "them out; this is non-portable out-of-spec "
  2331.                            "behavior\n",
  2332.                            _mesa_shader_stage_to_string(i));
  2333.          } else {
  2334.             linker_error(prog, "Too many %s shader default uniform block "
  2335.                          "components\n",
  2336.                          _mesa_shader_stage_to_string(i));
  2337.          }
  2338.       }
  2339.  
  2340.       if (sh->num_combined_uniform_components >
  2341.           ctx->Const.Program[i].MaxCombinedUniformComponents) {
  2342.          if (ctx->Const.GLSLSkipStrictMaxUniformLimitCheck) {
  2343.             linker_warning(prog, "Too many %s shader uniform components, "
  2344.                            "but the driver will try to optimize them out; "
  2345.                            "this is non-portable out-of-spec behavior\n",
  2346.                            _mesa_shader_stage_to_string(i));
  2347.          } else {
  2348.             linker_error(prog, "Too many %s shader uniform components\n",
  2349.                          _mesa_shader_stage_to_string(i));
  2350.          }
  2351.       }
  2352.    }
  2353.  
  2354.    unsigned blocks[MESA_SHADER_STAGES] = {0};
  2355.    unsigned total_uniform_blocks = 0;
  2356.  
  2357.    for (unsigned i = 0; i < prog->NumUniformBlocks; i++) {
  2358.       for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
  2359.          if (prog->UniformBlockStageIndex[j][i] != -1) {
  2360.             blocks[j]++;
  2361.             total_uniform_blocks++;
  2362.          }
  2363.       }
  2364.  
  2365.       if (total_uniform_blocks > ctx->Const.MaxCombinedUniformBlocks) {
  2366.          linker_error(prog, "Too many combined uniform blocks (%d/%d)\n",
  2367.                       prog->NumUniformBlocks,
  2368.                       ctx->Const.MaxCombinedUniformBlocks);
  2369.       } else {
  2370.          for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  2371.             const unsigned max_uniform_blocks =
  2372.                ctx->Const.Program[i].MaxUniformBlocks;
  2373.             if (blocks[i] > max_uniform_blocks) {
  2374.                linker_error(prog, "Too many %s uniform blocks (%d/%d)\n",
  2375.                             _mesa_shader_stage_to_string(i),
  2376.                             blocks[i],
  2377.                             max_uniform_blocks);
  2378.                break;
  2379.             }
  2380.          }
  2381.       }
  2382.    }
  2383. }
  2384.  
  2385. /**
  2386.  * Validate shader image resources.
  2387.  */
  2388. static void
  2389. check_image_resources(struct gl_context *ctx, struct gl_shader_program *prog)
  2390. {
  2391.    unsigned total_image_units = 0;
  2392.    unsigned fragment_outputs = 0;
  2393.  
  2394.    if (!ctx->Extensions.ARB_shader_image_load_store)
  2395.       return;
  2396.  
  2397.    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  2398.       struct gl_shader *sh = prog->_LinkedShaders[i];
  2399.  
  2400.       if (sh) {
  2401.          if (sh->NumImages > ctx->Const.Program[i].MaxImageUniforms)
  2402.             linker_error(prog, "Too many %s shader image uniforms\n",
  2403.                          _mesa_shader_stage_to_string(i));
  2404.  
  2405.          total_image_units += sh->NumImages;
  2406.  
  2407.          if (i == MESA_SHADER_FRAGMENT) {
  2408.             foreach_in_list(ir_instruction, node, sh->ir) {
  2409.                ir_variable *var = node->as_variable();
  2410.                if (var && var->data.mode == ir_var_shader_out)
  2411.                   fragment_outputs += var->type->count_attribute_slots();
  2412.             }
  2413.          }
  2414.       }
  2415.    }
  2416.  
  2417.    if (total_image_units > ctx->Const.MaxCombinedImageUniforms)
  2418.       linker_error(prog, "Too many combined image uniforms\n");
  2419.  
  2420.    if (total_image_units + fragment_outputs >
  2421.        ctx->Const.MaxCombinedImageUnitsAndFragmentOutputs)
  2422.       linker_error(prog, "Too many combined image uniforms and fragment outputs\n");
  2423. }
  2424.  
  2425.  
  2426. /**
  2427.  * Initializes explicit location slots to INACTIVE_UNIFORM_EXPLICIT_LOCATION
  2428.  * for a variable, checks for overlaps between other uniforms using explicit
  2429.  * locations.
  2430.  */
  2431. static bool
  2432. reserve_explicit_locations(struct gl_shader_program *prog,
  2433.                            string_to_uint_map *map, ir_variable *var)
  2434. {
  2435.    unsigned slots = var->type->uniform_locations();
  2436.    unsigned max_loc = var->data.location + slots - 1;
  2437.  
  2438.    /* Resize remap table if locations do not fit in the current one. */
  2439.    if (max_loc + 1 > prog->NumUniformRemapTable) {
  2440.       prog->UniformRemapTable =
  2441.          reralloc(prog, prog->UniformRemapTable,
  2442.                   gl_uniform_storage *,
  2443.                   max_loc + 1);
  2444.  
  2445.       if (!prog->UniformRemapTable) {
  2446.          linker_error(prog, "Out of memory during linking.\n");
  2447.          return false;
  2448.       }
  2449.  
  2450.       /* Initialize allocated space. */
  2451.       for (unsigned i = prog->NumUniformRemapTable; i < max_loc + 1; i++)
  2452.          prog->UniformRemapTable[i] = NULL;
  2453.  
  2454.       prog->NumUniformRemapTable = max_loc + 1;
  2455.    }
  2456.  
  2457.    for (unsigned i = 0; i < slots; i++) {
  2458.       unsigned loc = var->data.location + i;
  2459.  
  2460.       /* Check if location is already used. */
  2461.       if (prog->UniformRemapTable[loc] == INACTIVE_UNIFORM_EXPLICIT_LOCATION) {
  2462.  
  2463.          /* Possibly same uniform from a different stage, this is ok. */
  2464.          unsigned hash_loc;
  2465.          if (map->get(hash_loc, var->name) && hash_loc == loc - i)
  2466.                continue;
  2467.  
  2468.          /* ARB_explicit_uniform_location specification states:
  2469.           *
  2470.           *     "No two default-block uniform variables in the program can have
  2471.           *     the same location, even if they are unused, otherwise a compiler
  2472.           *     or linker error will be generated."
  2473.           */
  2474.          linker_error(prog,
  2475.                       "location qualifier for uniform %s overlaps "
  2476.                       "previously used location\n",
  2477.                       var->name);
  2478.          return false;
  2479.       }
  2480.  
  2481.       /* Initialize location as inactive before optimization
  2482.        * rounds and location assignment.
  2483.        */
  2484.       prog->UniformRemapTable[loc] = INACTIVE_UNIFORM_EXPLICIT_LOCATION;
  2485.    }
  2486.  
  2487.    /* Note, base location used for arrays. */
  2488.    map->put(var->data.location, var->name);
  2489.  
  2490.    return true;
  2491. }
  2492.  
  2493. /**
  2494.  * Check and reserve all explicit uniform locations, called before
  2495.  * any optimizations happen to handle also inactive uniforms and
  2496.  * inactive array elements that may get trimmed away.
  2497.  */
  2498. static void
  2499. check_explicit_uniform_locations(struct gl_context *ctx,
  2500.                                  struct gl_shader_program *prog)
  2501. {
  2502.    if (!ctx->Extensions.ARB_explicit_uniform_location)
  2503.       return;
  2504.  
  2505.    /* This map is used to detect if overlapping explicit locations
  2506.     * occur with the same uniform (from different stage) or a different one.
  2507.     */
  2508.    string_to_uint_map *uniform_map = new string_to_uint_map;
  2509.  
  2510.    if (!uniform_map) {
  2511.       linker_error(prog, "Out of memory during linking.\n");
  2512.       return;
  2513.    }
  2514.  
  2515.    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  2516.       struct gl_shader *sh = prog->_LinkedShaders[i];
  2517.  
  2518.       if (!sh)
  2519.          continue;
  2520.  
  2521.       foreach_in_list(ir_instruction, node, sh->ir) {
  2522.          ir_variable *var = node->as_variable();
  2523.          if ((var && var->data.mode == ir_var_uniform) &&
  2524.              var->data.explicit_location) {
  2525.             if (!reserve_explicit_locations(prog, uniform_map, var)) {
  2526.                delete uniform_map;
  2527.                return;
  2528.             }
  2529.          }
  2530.       }
  2531.    }
  2532.  
  2533.    delete uniform_map;
  2534. }
  2535.  
  2536. static bool
  2537. add_program_resource(struct gl_shader_program *prog, GLenum type,
  2538.                      const void *data, uint8_t stages)
  2539. {
  2540.    assert(data);
  2541.  
  2542.    /* If resource already exists, do not add it again. */
  2543.    for (unsigned i = 0; i < prog->NumProgramResourceList; i++)
  2544.       if (prog->ProgramResourceList[i].Data == data)
  2545.          return true;
  2546.  
  2547.    prog->ProgramResourceList =
  2548.       reralloc(prog,
  2549.                prog->ProgramResourceList,
  2550.                gl_program_resource,
  2551.                prog->NumProgramResourceList + 1);
  2552.  
  2553.    if (!prog->ProgramResourceList) {
  2554.       linker_error(prog, "Out of memory during linking.\n");
  2555.       return false;
  2556.    }
  2557.  
  2558.    struct gl_program_resource *res =
  2559.       &prog->ProgramResourceList[prog->NumProgramResourceList];
  2560.  
  2561.    res->Type = type;
  2562.    res->Data = data;
  2563.    res->StageReferences = stages;
  2564.  
  2565.    prog->NumProgramResourceList++;
  2566.  
  2567.    return true;
  2568. }
  2569.  
  2570. /**
  2571.  * Function builds a stage reference bitmask from variable name.
  2572.  */
  2573. static uint8_t
  2574. build_stageref(struct gl_shader_program *shProg, const char *name)
  2575. {
  2576.    uint8_t stages = 0;
  2577.  
  2578.    /* Note, that we assume MAX 8 stages, if there will be more stages, type
  2579.     * used for reference mask in gl_program_resource will need to be changed.
  2580.     */
  2581.    assert(MESA_SHADER_STAGES < 8);
  2582.  
  2583.    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  2584.       struct gl_shader *sh = shProg->_LinkedShaders[i];
  2585.       if (!sh)
  2586.          continue;
  2587.       ir_variable *var = sh->symbols->get_variable(name);
  2588.       if (var)
  2589.          stages |= (1 << i);
  2590.    }
  2591.    return stages;
  2592. }
  2593.  
  2594. static bool
  2595. add_interface_variables(struct gl_shader_program *shProg,
  2596.                         struct gl_shader *sh, GLenum programInterface)
  2597. {
  2598.    foreach_in_list(ir_instruction, node, sh->ir) {
  2599.       ir_variable *var = node->as_variable();
  2600.       uint8_t mask = 0;
  2601.  
  2602.       if (!var)
  2603.          continue;
  2604.  
  2605.       switch (var->data.mode) {
  2606.       /* From GL 4.3 core spec, section 11.1.1 (Vertex Attributes):
  2607.        * "For GetActiveAttrib, all active vertex shader input variables
  2608.        * are enumerated, including the special built-in inputs gl_VertexID
  2609.        * and gl_InstanceID."
  2610.        */
  2611.       case ir_var_system_value:
  2612.          if (var->data.location != SYSTEM_VALUE_VERTEX_ID &&
  2613.              var->data.location != SYSTEM_VALUE_VERTEX_ID_ZERO_BASE &&
  2614.              var->data.location != SYSTEM_VALUE_INSTANCE_ID)
  2615.             continue;
  2616.          /* Mark special built-in inputs referenced by the vertex stage so
  2617.           * that they are considered active by the shader queries.
  2618.           */
  2619.          mask = (1 << (MESA_SHADER_VERTEX));
  2620.          /* FALLTHROUGH */
  2621.       case ir_var_shader_in:
  2622.          if (programInterface != GL_PROGRAM_INPUT)
  2623.             continue;
  2624.          break;
  2625.       case ir_var_shader_out:
  2626.          if (programInterface != GL_PROGRAM_OUTPUT)
  2627.             continue;
  2628.          break;
  2629.       default:
  2630.          continue;
  2631.       };
  2632.  
  2633.       if (!add_program_resource(shProg, programInterface, var,
  2634.                                 build_stageref(shProg, var->name) | mask))
  2635.          return false;
  2636.    }
  2637.    return true;
  2638. }
  2639.  
  2640. /**
  2641.  * Builds up a list of program resources that point to existing
  2642.  * resource data.
  2643.  */
  2644. static void
  2645. build_program_resource_list(struct gl_context *ctx,
  2646.                             struct gl_shader_program *shProg)
  2647. {
  2648.    /* Rebuild resource list. */
  2649.    if (shProg->ProgramResourceList) {
  2650.       ralloc_free(shProg->ProgramResourceList);
  2651.       shProg->ProgramResourceList = NULL;
  2652.       shProg->NumProgramResourceList = 0;
  2653.    }
  2654.  
  2655.    int input_stage = MESA_SHADER_STAGES, output_stage = 0;
  2656.  
  2657.    /* Determine first input and final output stage. These are used to
  2658.     * detect which variables should be enumerated in the resource list
  2659.     * for GL_PROGRAM_INPUT and GL_PROGRAM_OUTPUT.
  2660.     */
  2661.    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  2662.       if (!shProg->_LinkedShaders[i])
  2663.          continue;
  2664.       if (input_stage == MESA_SHADER_STAGES)
  2665.          input_stage = i;
  2666.       output_stage = i;
  2667.    }
  2668.  
  2669.    /* Empty shader, no resources. */
  2670.    if (input_stage == MESA_SHADER_STAGES && output_stage == 0)
  2671.       return;
  2672.  
  2673.    /* Add inputs and outputs to the resource list. */
  2674.    if (!add_interface_variables(shProg, shProg->_LinkedShaders[input_stage],
  2675.                                 GL_PROGRAM_INPUT))
  2676.       return;
  2677.  
  2678.    if (!add_interface_variables(shProg, shProg->_LinkedShaders[output_stage],
  2679.                                 GL_PROGRAM_OUTPUT))
  2680.       return;
  2681.  
  2682.    /* Add transform feedback varyings. */
  2683.    if (shProg->LinkedTransformFeedback.NumVarying > 0) {
  2684.       for (int i = 0; i < shProg->LinkedTransformFeedback.NumVarying; i++) {
  2685.          uint8_t stageref =
  2686.             build_stageref(shProg,
  2687.                            shProg->LinkedTransformFeedback.Varyings[i].Name);
  2688.          if (!add_program_resource(shProg, GL_TRANSFORM_FEEDBACK_VARYING,
  2689.                                    &shProg->LinkedTransformFeedback.Varyings[i],
  2690.                                    stageref))
  2691.          return;
  2692.       }
  2693.    }
  2694.  
  2695.    /* Add uniforms from uniform storage. */
  2696.    for (unsigned i = 0; i < shProg->NumUserUniformStorage; i++) {
  2697.       /* Do not add uniforms internally used by Mesa. */
  2698.       if (shProg->UniformStorage[i].hidden)
  2699.          continue;
  2700.  
  2701.       uint8_t stageref =
  2702.          build_stageref(shProg, shProg->UniformStorage[i].name);
  2703.  
  2704.       /* Add stagereferences for uniforms in a uniform block. */
  2705.       int block_index = shProg->UniformStorage[i].block_index;
  2706.       if (block_index != -1) {
  2707.          for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
  2708.              if (shProg->UniformBlockStageIndex[j][block_index] != -1)
  2709.                 stageref |= (1 << j);
  2710.          }
  2711.       }
  2712.  
  2713.       if (!add_program_resource(shProg, GL_UNIFORM,
  2714.                                 &shProg->UniformStorage[i], stageref))
  2715.          return;
  2716.    }
  2717.  
  2718.    /* Add program uniform blocks. */
  2719.    for (unsigned i = 0; i < shProg->NumUniformBlocks; i++) {
  2720.       if (!add_program_resource(shProg, GL_UNIFORM_BLOCK,
  2721.           &shProg->UniformBlocks[i], 0))
  2722.          return;
  2723.    }
  2724.  
  2725.    /* Add atomic counter buffers. */
  2726.    for (unsigned i = 0; i < shProg->NumAtomicBuffers; i++) {
  2727.       if (!add_program_resource(shProg, GL_ATOMIC_COUNTER_BUFFER,
  2728.                                 &shProg->AtomicBuffers[i], 0))
  2729.          return;
  2730.    }
  2731.  
  2732.    /* TODO - following extensions will require more resource types:
  2733.     *
  2734.     *    GL_ARB_shader_storage_buffer_object
  2735.     *    GL_ARB_shader_subroutine
  2736.     */
  2737. }
  2738.  
  2739.  
  2740. void
  2741. link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
  2742. {
  2743.    tfeedback_decl *tfeedback_decls = NULL;
  2744.    unsigned num_tfeedback_decls = prog->TransformFeedback.NumVarying;
  2745.  
  2746.    void *mem_ctx = ralloc_context(NULL); // temporary linker context
  2747.  
  2748.    prog->LinkStatus = true; /* All error paths will set this to false */
  2749.    prog->Validated = false;
  2750.    prog->_Used = false;
  2751.  
  2752.    prog->ARB_fragment_coord_conventions_enable = false;
  2753.  
  2754.    /* Separate the shaders into groups based on their type.
  2755.     */
  2756.    struct gl_shader **shader_list[MESA_SHADER_STAGES];
  2757.    unsigned num_shaders[MESA_SHADER_STAGES];
  2758.  
  2759.    for (int i = 0; i < MESA_SHADER_STAGES; i++) {
  2760.       shader_list[i] = (struct gl_shader **)
  2761.          calloc(prog->NumShaders, sizeof(struct gl_shader *));
  2762.       num_shaders[i] = 0;
  2763.    }
  2764.  
  2765.    unsigned min_version = UINT_MAX;
  2766.    unsigned max_version = 0;
  2767.    const bool is_es_prog =
  2768.       (prog->NumShaders > 0 && prog->Shaders[0]->IsES) ? true : false;
  2769.    for (unsigned i = 0; i < prog->NumShaders; i++) {
  2770.       min_version = MIN2(min_version, prog->Shaders[i]->Version);
  2771.       max_version = MAX2(max_version, prog->Shaders[i]->Version);
  2772.  
  2773.       if (prog->Shaders[i]->IsES != is_es_prog) {
  2774.          linker_error(prog, "all shaders must use same shading "
  2775.                       "language version\n");
  2776.          goto done;
  2777.       }
  2778.  
  2779.       if (prog->Shaders[i]->ARB_fragment_coord_conventions_enable) {
  2780.          prog->ARB_fragment_coord_conventions_enable = true;
  2781.       }
  2782.  
  2783.       gl_shader_stage shader_type = prog->Shaders[i]->Stage;
  2784.       shader_list[shader_type][num_shaders[shader_type]] = prog->Shaders[i];
  2785.       num_shaders[shader_type]++;
  2786.    }
  2787.  
  2788.    /* In desktop GLSL, different shader versions may be linked together.  In
  2789.     * GLSL ES, all shader versions must be the same.
  2790.     */
  2791.    if (is_es_prog && min_version != max_version) {
  2792.       linker_error(prog, "all shaders must use same shading "
  2793.                    "language version\n");
  2794.       goto done;
  2795.    }
  2796.  
  2797.    prog->Version = max_version;
  2798.    prog->IsES = is_es_prog;
  2799.  
  2800.    /* Geometry shaders have to be linked with vertex shaders.
  2801.     */
  2802.    if (num_shaders[MESA_SHADER_GEOMETRY] > 0 &&
  2803.        num_shaders[MESA_SHADER_VERTEX] == 0 &&
  2804.        !prog->SeparateShader) {
  2805.       linker_error(prog, "Geometry shader must be linked with "
  2806.                    "vertex shader\n");
  2807.       goto done;
  2808.    }
  2809.  
  2810.    /* Compute shaders have additional restrictions. */
  2811.    if (num_shaders[MESA_SHADER_COMPUTE] > 0 &&
  2812.        num_shaders[MESA_SHADER_COMPUTE] != prog->NumShaders) {
  2813.       linker_error(prog, "Compute shaders may not be linked with any other "
  2814.                    "type of shader\n");
  2815.    }
  2816.  
  2817.    for (unsigned int i = 0; i < MESA_SHADER_STAGES; i++) {
  2818.       if (prog->_LinkedShaders[i] != NULL)
  2819.          ctx->Driver.DeleteShader(ctx, prog->_LinkedShaders[i]);
  2820.  
  2821.       prog->_LinkedShaders[i] = NULL;
  2822.    }
  2823.  
  2824.    /* Link all shaders for a particular stage and validate the result.
  2825.     */
  2826.    for (int stage = 0; stage < MESA_SHADER_STAGES; stage++) {
  2827.       if (num_shaders[stage] > 0) {
  2828.          gl_shader *const sh =
  2829.             link_intrastage_shaders(mem_ctx, ctx, prog, shader_list[stage],
  2830.                                     num_shaders[stage]);
  2831.  
  2832.          if (!prog->LinkStatus) {
  2833.             if (sh)
  2834.                ctx->Driver.DeleteShader(ctx, sh);
  2835.             goto done;
  2836.          }
  2837.  
  2838.          switch (stage) {
  2839.          case MESA_SHADER_VERTEX:
  2840.             validate_vertex_shader_executable(prog, sh);
  2841.             break;
  2842.          case MESA_SHADER_GEOMETRY:
  2843.             validate_geometry_shader_executable(prog, sh);
  2844.             break;
  2845.          case MESA_SHADER_FRAGMENT:
  2846.             validate_fragment_shader_executable(prog, sh);
  2847.             break;
  2848.          }
  2849.          if (!prog->LinkStatus) {
  2850.             if (sh)
  2851.                ctx->Driver.DeleteShader(ctx, sh);
  2852.             goto done;
  2853.          }
  2854.  
  2855.          _mesa_reference_shader(ctx, &prog->_LinkedShaders[stage], sh);
  2856.       }
  2857.    }
  2858.  
  2859.    if (num_shaders[MESA_SHADER_GEOMETRY] > 0)
  2860.       prog->LastClipDistanceArraySize = prog->Geom.ClipDistanceArraySize;
  2861.    else if (num_shaders[MESA_SHADER_VERTEX] > 0)
  2862.       prog->LastClipDistanceArraySize = prog->Vert.ClipDistanceArraySize;
  2863.    else
  2864.       prog->LastClipDistanceArraySize = 0; /* Not used */
  2865.  
  2866.    /* Here begins the inter-stage linking phase.  Some initial validation is
  2867.     * performed, then locations are assigned for uniforms, attributes, and
  2868.     * varyings.
  2869.     */
  2870.    cross_validate_uniforms(prog);
  2871.    if (!prog->LinkStatus)
  2872.       goto done;
  2873.  
  2874.    unsigned prev;
  2875.  
  2876.    for (prev = 0; prev <= MESA_SHADER_FRAGMENT; prev++) {
  2877.       if (prog->_LinkedShaders[prev] != NULL)
  2878.          break;
  2879.    }
  2880.  
  2881.    check_explicit_uniform_locations(ctx, prog);
  2882.    if (!prog->LinkStatus)
  2883.       goto done;
  2884.  
  2885.    /* Validate the inputs of each stage with the output of the preceding
  2886.     * stage.
  2887.     */
  2888.    for (unsigned i = prev + 1; i <= MESA_SHADER_FRAGMENT; i++) {
  2889.       if (prog->_LinkedShaders[i] == NULL)
  2890.          continue;
  2891.  
  2892.       validate_interstage_inout_blocks(prog, prog->_LinkedShaders[prev],
  2893.                                        prog->_LinkedShaders[i]);
  2894.       if (!prog->LinkStatus)
  2895.          goto done;
  2896.  
  2897.       cross_validate_outputs_to_inputs(prog,
  2898.                                        prog->_LinkedShaders[prev],
  2899.                                        prog->_LinkedShaders[i]);
  2900.       if (!prog->LinkStatus)
  2901.          goto done;
  2902.  
  2903.       prev = i;
  2904.    }
  2905.  
  2906.    /* Cross-validate uniform blocks between shader stages */
  2907.    validate_interstage_uniform_blocks(prog, prog->_LinkedShaders,
  2908.                                       MESA_SHADER_STAGES);
  2909.    if (!prog->LinkStatus)
  2910.       goto done;
  2911.  
  2912.    for (unsigned int i = 0; i < MESA_SHADER_STAGES; i++) {
  2913.       if (prog->_LinkedShaders[i] != NULL)
  2914.          lower_named_interface_blocks(mem_ctx, prog->_LinkedShaders[i]);
  2915.    }
  2916.  
  2917.    /* Implement the GLSL 1.30+ rule for discard vs infinite loops Do
  2918.     * it before optimization because we want most of the checks to get
  2919.     * dropped thanks to constant propagation.
  2920.     *
  2921.     * This rule also applies to GLSL ES 3.00.
  2922.     */
  2923.    if (max_version >= (is_es_prog ? 300 : 130)) {
  2924.       struct gl_shader *sh = prog->_LinkedShaders[MESA_SHADER_FRAGMENT];
  2925.       if (sh) {
  2926.          lower_discard_flow(sh->ir);
  2927.       }
  2928.    }
  2929.  
  2930.    if (!interstage_cross_validate_uniform_blocks(prog))
  2931.       goto done;
  2932.  
  2933.    /* Do common optimization before assigning storage for attributes,
  2934.     * uniforms, and varyings.  Later optimization could possibly make
  2935.     * some of that unused.
  2936.     */
  2937.    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  2938.       if (prog->_LinkedShaders[i] == NULL)
  2939.          continue;
  2940.  
  2941.       detect_recursion_linked(prog, prog->_LinkedShaders[i]->ir);
  2942.       if (!prog->LinkStatus)
  2943.          goto done;
  2944.  
  2945.       if (ctx->Const.ShaderCompilerOptions[i].LowerClipDistance) {
  2946.          lower_clip_distance(prog->_LinkedShaders[i]);
  2947.       }
  2948.  
  2949.       while (do_common_optimization(prog->_LinkedShaders[i]->ir, true, false,
  2950.                                     &ctx->Const.ShaderCompilerOptions[i],
  2951.                                     ctx->Const.NativeIntegers))
  2952.          ;
  2953.  
  2954.       lower_const_arrays_to_uniforms(prog->_LinkedShaders[i]->ir);
  2955.    }
  2956.  
  2957.    /* Check and validate stream emissions in geometry shaders */
  2958.    validate_geometry_shader_emissions(ctx, prog);
  2959.  
  2960.    /* Mark all generic shader inputs and outputs as unpaired. */
  2961.    for (unsigned i = MESA_SHADER_VERTEX; i <= MESA_SHADER_FRAGMENT; i++) {
  2962.       if (prog->_LinkedShaders[i] != NULL) {
  2963.          link_invalidate_variable_locations(prog->_LinkedShaders[i]->ir);
  2964.       }
  2965.    }
  2966.  
  2967.    /* FINISHME: The value of the max_attribute_index parameter is
  2968.     * FINISHME: implementation dependent based on the value of
  2969.     * FINISHME: GL_MAX_VERTEX_ATTRIBS.  GL_MAX_VERTEX_ATTRIBS must be
  2970.     * FINISHME: at least 16, so hardcode 16 for now.
  2971.     */
  2972.    if (!assign_attribute_or_color_locations(prog, MESA_SHADER_VERTEX, 16)) {
  2973.       goto done;
  2974.    }
  2975.  
  2976.    if (!assign_attribute_or_color_locations(prog, MESA_SHADER_FRAGMENT, MAX2(ctx->Const.MaxDrawBuffers, ctx->Const.MaxDualSourceDrawBuffers))) {
  2977.       goto done;
  2978.    }
  2979.  
  2980.    unsigned first, last;
  2981.  
  2982.    first = MESA_SHADER_STAGES;
  2983.    last = 0;
  2984.  
  2985.    /* Determine first and last stage. */
  2986.    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  2987.       if (!prog->_LinkedShaders[i])
  2988.          continue;
  2989.       if (first == MESA_SHADER_STAGES)
  2990.          first = i;
  2991.       last = i;
  2992.    }
  2993.  
  2994.    if (num_tfeedback_decls != 0) {
  2995.       /* From GL_EXT_transform_feedback:
  2996.        *   A program will fail to link if:
  2997.        *
  2998.        *   * the <count> specified by TransformFeedbackVaryingsEXT is
  2999.        *     non-zero, but the program object has no vertex or geometry
  3000.        *     shader;
  3001.        */
  3002.       if (first == MESA_SHADER_FRAGMENT) {
  3003.          linker_error(prog, "Transform feedback varyings specified, but "
  3004.                       "no vertex or geometry shader is present.\n");
  3005.          goto done;
  3006.       }
  3007.  
  3008.       tfeedback_decls = ralloc_array(mem_ctx, tfeedback_decl,
  3009.                                      prog->TransformFeedback.NumVarying);
  3010.       if (!parse_tfeedback_decls(ctx, prog, mem_ctx, num_tfeedback_decls,
  3011.                                  prog->TransformFeedback.VaryingNames,
  3012.                                  tfeedback_decls))
  3013.          goto done;
  3014.    }
  3015.  
  3016.    /* Linking the stages in the opposite order (from fragment to vertex)
  3017.     * ensures that inter-shader outputs written to in an earlier stage are
  3018.     * eliminated if they are (transitively) not used in a later stage.
  3019.     */
  3020.    int next;
  3021.  
  3022.    if (first < MESA_SHADER_FRAGMENT) {
  3023.       gl_shader *const sh = prog->_LinkedShaders[last];
  3024.  
  3025.       if (first == MESA_SHADER_GEOMETRY) {
  3026.          /* There was no vertex shader, but we still have to assign varying
  3027.           * locations for use by geometry shader inputs in SSO.
  3028.           *
  3029.           * If the shader is not separable (i.e., prog->SeparateShader is
  3030.           * false), linking will have already failed when first is
  3031.           * MESA_SHADER_GEOMETRY.
  3032.           */
  3033.          if (!assign_varying_locations(ctx, mem_ctx, prog,
  3034.                                        NULL, prog->_LinkedShaders[first],
  3035.                                        num_tfeedback_decls, tfeedback_decls,
  3036.                                        prog->Geom.VerticesIn))
  3037.             goto done;
  3038.       }
  3039.  
  3040.       if (last != MESA_SHADER_FRAGMENT &&
  3041.          (num_tfeedback_decls != 0 || prog->SeparateShader)) {
  3042.          /* There was no fragment shader, but we still have to assign varying
  3043.           * locations for use by transform feedback.
  3044.           */
  3045.          if (!assign_varying_locations(ctx, mem_ctx, prog,
  3046.                                        sh, NULL,
  3047.                                        num_tfeedback_decls, tfeedback_decls,
  3048.                                        0))
  3049.             goto done;
  3050.       }
  3051.  
  3052.       do_dead_builtin_varyings(ctx, sh, NULL,
  3053.                                num_tfeedback_decls, tfeedback_decls);
  3054.  
  3055.       if (!prog->SeparateShader)
  3056.          demote_shader_inputs_and_outputs(sh, ir_var_shader_out);
  3057.  
  3058.       /* Eliminate code that is now dead due to unused outputs being demoted.
  3059.        */
  3060.       while (do_dead_code(sh->ir, false))
  3061.          ;
  3062.    }
  3063.    else if (first == MESA_SHADER_FRAGMENT) {
  3064.       /* If the program only contains a fragment shader...
  3065.        */
  3066.       gl_shader *const sh = prog->_LinkedShaders[first];
  3067.  
  3068.       do_dead_builtin_varyings(ctx, NULL, sh,
  3069.                                num_tfeedback_decls, tfeedback_decls);
  3070.  
  3071.       if (prog->SeparateShader) {
  3072.          if (!assign_varying_locations(ctx, mem_ctx, prog,
  3073.                                        NULL /* producer */,
  3074.                                        sh /* consumer */,
  3075.                                        0 /* num_tfeedback_decls */,
  3076.                                        NULL /* tfeedback_decls */,
  3077.                                        0 /* gs_input_vertices */))
  3078.             goto done;
  3079.       } else
  3080.          demote_shader_inputs_and_outputs(sh, ir_var_shader_in);
  3081.  
  3082.       while (do_dead_code(sh->ir, false))
  3083.          ;
  3084.    }
  3085.  
  3086.    next = last;
  3087.    for (int i = next - 1; i >= 0; i--) {
  3088.       if (prog->_LinkedShaders[i] == NULL)
  3089.          continue;
  3090.  
  3091.       gl_shader *const sh_i = prog->_LinkedShaders[i];
  3092.       gl_shader *const sh_next = prog->_LinkedShaders[next];
  3093.       unsigned gs_input_vertices =
  3094.          next == MESA_SHADER_GEOMETRY ? prog->Geom.VerticesIn : 0;
  3095.  
  3096.       if (!assign_varying_locations(ctx, mem_ctx, prog, sh_i, sh_next,
  3097.                 next == MESA_SHADER_FRAGMENT ? num_tfeedback_decls : 0,
  3098.                 tfeedback_decls, gs_input_vertices))
  3099.          goto done;
  3100.  
  3101.       do_dead_builtin_varyings(ctx, sh_i, sh_next,
  3102.                 next == MESA_SHADER_FRAGMENT ? num_tfeedback_decls : 0,
  3103.                 tfeedback_decls);
  3104.  
  3105.       demote_shader_inputs_and_outputs(sh_i, ir_var_shader_out);
  3106.       demote_shader_inputs_and_outputs(sh_next, ir_var_shader_in);
  3107.  
  3108.       /* Eliminate code that is now dead due to unused outputs being demoted.
  3109.        */
  3110.       while (do_dead_code(sh_i->ir, false))
  3111.          ;
  3112.       while (do_dead_code(sh_next->ir, false))
  3113.          ;
  3114.  
  3115.       /* This must be done after all dead varyings are eliminated. */
  3116.       if (!check_against_output_limit(ctx, prog, sh_i))
  3117.          goto done;
  3118.       if (!check_against_input_limit(ctx, prog, sh_next))
  3119.          goto done;
  3120.  
  3121.       next = i;
  3122.    }
  3123.  
  3124.    if (!store_tfeedback_info(ctx, prog, num_tfeedback_decls, tfeedback_decls))
  3125.       goto done;
  3126.  
  3127.    update_array_sizes(prog);
  3128.    link_assign_uniform_locations(prog, ctx->Const.UniformBooleanTrue);
  3129.    link_assign_atomic_counter_resources(ctx, prog);
  3130.    store_fragdepth_layout(prog);
  3131.  
  3132.    check_resources(ctx, prog);
  3133.    check_image_resources(ctx, prog);
  3134.    link_check_atomic_counter_resources(ctx, prog);
  3135.  
  3136.    if (!prog->LinkStatus)
  3137.       goto done;
  3138.  
  3139.    /* OpenGL ES requires that a vertex shader and a fragment shader both be
  3140.     * present in a linked program. GL_ARB_ES2_compatibility doesn't say
  3141.     * anything about shader linking when one of the shaders (vertex or
  3142.     * fragment shader) is absent. So, the extension shouldn't change the
  3143.     * behavior specified in GLSL specification.
  3144.     */
  3145.    if (!prog->SeparateShader && ctx->API == API_OPENGLES2) {
  3146.       if (prog->_LinkedShaders[MESA_SHADER_VERTEX] == NULL) {
  3147.          linker_error(prog, "program lacks a vertex shader\n");
  3148.       } else if (prog->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL) {
  3149.          linker_error(prog, "program lacks a fragment shader\n");
  3150.       }
  3151.    }
  3152.  
  3153.    build_program_resource_list(ctx, prog);
  3154.    if (!prog->LinkStatus)
  3155.       goto done;
  3156.  
  3157.    /* FINISHME: Assign fragment shader output locations. */
  3158.  
  3159. done:
  3160.    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
  3161.       free(shader_list[i]);
  3162.       if (prog->_LinkedShaders[i] == NULL)
  3163.          continue;
  3164.  
  3165.       /* Do a final validation step to make sure that the IR wasn't
  3166.        * invalidated by any modifications performed after intrastage linking.
  3167.        */
  3168.       validate_ir_tree(prog->_LinkedShaders[i]->ir);
  3169.  
  3170.       /* Retain any live IR, but trash the rest. */
  3171.       reparent_ir(prog->_LinkedShaders[i]->ir, prog->_LinkedShaders[i]->ir);
  3172.  
  3173.       /* The symbol table in the linked shaders may contain references to
  3174.        * variables that were removed (e.g., unused uniforms).  Since it may
  3175.        * contain junk, there is no possible valid use.  Delete it and set the
  3176.        * pointer to NULL.
  3177.        */
  3178.       delete prog->_LinkedShaders[i]->symbols;
  3179.       prog->_LinkedShaders[i]->symbols = NULL;
  3180.    }
  3181.  
  3182.    ralloc_free(mem_ctx);
  3183. }
  3184.