linker.cpp

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 /**
  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 #include <cstdlib>
  67 #include <cstdio>
  68
  69 #include "glsl_symbol_table.h"
  70 #include "glsl_parser_extras.h"
  71 #include "ir.h"
  72 #include "program.h"
  73
  74 /**
  75  * Visitor that determines whether or not a variable is ever written.
  76  */
  77 class find_assignment_visitor : public ir_hierarchical_visitor {
  78 public:
  79    find_assignment_visitor(const char *name)
  80       : name(name), found(false)
  81    {
  82       /* empty */
  83    }
  84
  85    virtual ir_visitor_status visit_enter(ir_assignment *ir)
  86    {
  87       ir_variable *const var = ir->lhs->variable_referenced();
  88
  89       if (strcmp(name, var->name) == 0) {
  90          found = true;
  91          return visit_stop;
  92       }
  93
  94       return visit_continue_with_parent;
  95    }
  96
  97    bool variable_found()
  98    {
  99       return found;
 100    }
 101
 102 private:
 103    const char *name;       /**< Find writes to a variable with this name. */
 104    bool found;             /**< Was a write to the variable found? */
 105 };
 106
 107
 108 /**
 109  * Verify that a vertex shader executable meets all semantic requirements
 110  *
 111  * \param shader  Vertex shader executable to be verified
 112  */
 113 bool
 114 validate_vertex_shader_executable(struct glsl_shader *shader)
 115 {
 116    if (shader == NULL)
 117       return true;
 118
 119    if (!shader->symbols->get_function("main")) {
 120       printf("error: vertex shader lacks `main'\n");
 121       return false;
 122    }
 123
 124    find_assignment_visitor find("gl_Position");
 125    find.run(&shader->ir);
 126    if (!find.variable_found()) {
 127       printf("error: vertex shader does not write to `gl_Position'\n");
 128       return false;
 129    }
 130
 131    return true;
 132 }
 133
 134
 135 /**
 136  * Verify that a fragment shader executable meets all semantic requirements
 137  *
 138  * \param shader  Fragment shader executable to be verified
 139  */
 140 bool
 141 validate_fragment_shader_executable(struct glsl_shader *shader)
 142 {
 143    if (shader == NULL)
 144       return true;
 145
 146    if (!shader->symbols->get_function("main")) {
 147       printf("error: fragment shader lacks `main'\n");
 148       return false;
 149    }
 150
 151    find_assignment_visitor frag_color("gl_FragColor");
 152    find_assignment_visitor frag_data("gl_FragData");
 153
 154    frag_color.run(&shader->ir);
 155    frag_data.run(&shader->ir);
 156
 157    if (!frag_color.variable_found() && !frag_data.variable_found()) {
 158       printf("error: fragment shader does not write to `gl_FragColor' or "
 159              "`gl_FragData'\n");
 160       return false;
 161    }
 162
 163    if (frag_color.variable_found() && frag_data.variable_found()) {
 164       printf("error: fragment shader write to both `gl_FragColor' and "
 165              "`gl_FragData'\n");
 166       return false;
 167    }
 168
 169    return true;
 170 }
 171
 172
 173 void
 174 link_shaders(struct glsl_program *prog)
 175 {
 176    prog->LinkStatus = false;
 177    prog->Validated = false;
 178    prog->_Used = false;
 179
 180    /* Separate the shaders into groups based on their type.
 181     */
 182    struct glsl_shader **vert_shader_list;
 183    unsigned num_vert_shaders = 0;
 184    struct glsl_shader **frag_shader_list;
 185    unsigned num_frag_shaders = 0;
 186
 187    vert_shader_list = (struct glsl_shader **)
 188       calloc(2 * prog->NumShaders, sizeof(struct glsl_shader *));
 189    frag_shader_list =  &vert_shader_list[prog->NumShaders];
 190
 191    for (unsigned i = 0; i < prog->NumShaders; i++) {
 192       switch (prog->Shaders[i]->Type) {
 193       case GL_VERTEX_SHADER:
 194          vert_shader_list[num_vert_shaders] = prog->Shaders[i];
 195          num_vert_shaders++;
 196          break;
 197       case GL_FRAGMENT_SHADER:
 198          frag_shader_list[num_frag_shaders] = prog->Shaders[i];
 199          num_frag_shaders++;
 200          break;
 201       case GL_GEOMETRY_SHADER:
 202          /* FINISHME: Support geometry shaders. */
 203          assert(prog->Shaders[i]->Type != GL_GEOMETRY_SHADER);
 204          break;
 205       }
 206    }
 207
 208    /* FINISHME: Implement intra-stage linking. */
 209    assert(num_vert_shaders <= 1);
 210    assert(num_frag_shaders <= 1);
 211
 212    /* Verify that each of the per-target executables is valid.
 213     */
 214    if (!validate_vertex_shader_executable(vert_shader_list[0])
 215        || !validate_fragment_shader_executable(frag_shader_list[0]))
 216       goto done;
 217
 218
 219    /* FINISHME: Perform inter-stage linking. */
 220
 221    prog->LinkStatus = true;
 222
 223 done:
 224    free(vert_shader_list);
 225 }