egl-static: fix printf warning

[mesa.git] / src / glsl / linker.cpp

diff --git a/src/glsl/linker.cpp b/src/glsl/linker.cpp
index 509575192e7493f873a132366331fa8cf3be59dd..49b6b8f4a5e84ece80fa5fcb3c3ec7e074e6ad9e 100644 (file)
--- a/src/glsl/linker.cpp
+++ b/src/glsl/linker.cpp
@@ -101,7 +101,7 @@ public:
 
    virtual ir_visitor_status visit_enter(ir_call *ir)
    {
-      exec_list_iterator sig_iter = ir->get_callee()->parameters.iterator();
+      exec_list_iterator sig_iter = ir->callee->parameters.iterator();
       foreach_iter(exec_list_iterator, iter, *ir) {
         ir_rvalue *param_rval = (ir_rvalue *)iter.get();
         ir_variable *sig_param = (ir_variable *)sig_iter.get();
@@ -117,6 +117,15 @@ public:
         sig_iter.next();
       }
 
+      if (ir->return_deref != NULL) {
+        ir_variable *const var = ir->return_deref->variable_referenced();
+
+        if (strcmp(name, var->name) == 0) {
+           found = true;
+           return visit_stop;
+        }
+      }
+
       return visit_continue_with_parent;
    }
 
@@ -258,11 +267,36 @@ validate_vertex_shader_executable(struct gl_shader_program *prog,
    if (shader == NULL)
       return true;
 
-   find_assignment_visitor find("gl_Position");
-   find.run(shader->ir);
-   if (!find.variable_found()) {
-      linker_error(prog, "vertex shader does not write to `gl_Position'\n");
-      return false;
+   /* From the GLSL 1.10 spec, page 48:
+    *
+    *     "The variable gl_Position is available only in the vertex
+    *      language and is intended for writing the homogeneous vertex
+    *      position. All executions of a well-formed vertex shader
+    *      executable must write a value into this variable. [...] The
+    *      variable gl_Position is available only in the vertex
+    *      language and is intended for writing the homogeneous vertex
+    *      position. All executions of a well-formed vertex shader
+    *      executable must write a value into this variable."
+    *
+    * while in GLSL 1.40 this text is changed to:
+    *
+    *     "The variable gl_Position is available only in the vertex
+    *      language and is intended for writing the homogeneous vertex
+    *      position. It can be written at any time during shader
+    *      execution. It may also be read back by a vertex shader
+    *      after being written. This value will be used by primitive
+    *      assembly, clipping, culling, and other fixed functionality
+    *      operations, if present, that operate on primitives after
+    *      vertex processing has occurred. Its value is undefined if
+    *      the vertex shader executable does not write gl_Position."
+    */
+   if (prog->Version < 140) {
+      find_assignment_visitor find("gl_Position");
+      find.run(shader->ir);
+      if (!find.variable_found()) {
+        linker_error(prog, "vertex shader does not write to `gl_Position'\n");
+        return false;
+      }
    }
 
    prog->Vert.ClipDistanceArraySize = 0;
@@ -805,6 +839,7 @@ move_non_declarations(exec_list *instructions, exec_node *last,
         continue;
 
       assert(inst->as_assignment()
+             || inst->as_call()
             || ((var != NULL) && (var->mode == ir_var_temporary)));
 
       if (make_copies) {
@@ -855,6 +890,27 @@ get_main_function_signature(gl_shader *sh)
 }
 
 
+/**
+ * This class is only used in link_intrastage_shaders() below but declaring
+ * it inside that function leads to compiler warnings with some versions of
+ * gcc.
+ */
+class array_sizing_visitor : public ir_hierarchical_visitor {
+public:
+   virtual ir_visitor_status visit(ir_variable *var)
+   {
+      if (var->type->is_array() && (var->type->length == 0)) {
+         const glsl_type *type =
+            glsl_type::get_array_instance(var->type->fields.array,
+                                          var->max_array_access + 1);
+         assert(type != NULL);
+         var->type = type;
+      }
+      return visit_continue;
+   }
+};
+
+
 /**
  * Combine a group of shaders for a single stage to generate a linked shader
  *
@@ -1005,22 +1061,7 @@ link_intrastage_shaders(void *mem_ctx,
     * max_array_access field.
     */
    if (linked != NULL) {
-      class array_sizing_visitor : public ir_hierarchical_visitor {
-      public:
-        virtual ir_visitor_status visit(ir_variable *var)
-        {
-           if (var->type->is_array() && (var->type->length == 0)) {
-              const glsl_type *type =
-                 glsl_type::get_array_instance(var->type->fields.array,
-                                               var->max_array_access + 1);
-
-              assert(type != NULL);
-              var->type = type;
-           }
-
-           return visit_continue;
-        }
-      } v;
+      array_sizing_visitor v;
 
       v.run(linked->ir);
    }
@@ -1288,9 +1329,11 @@ assign_attribute_or_color_locations(gl_shader_program *prog,
             * attribute overlaps any previously allocated bits.
             */
            if ((~(use_mask << attr) & used_locations) != used_locations) {
+              const char *const string = (target_index == MESA_SHADER_VERTEX)
+                 ? "vertex shader input" : "fragment shader output";
               linker_error(prog,
-                           "insufficient contiguous attribute locations "
-                           "available for vertex shader input `%s'",
+                           "insufficient contiguous locations "
+                           "available for %s `%s'", string,
                            var->name);
               return false;
            }
@@ -1339,7 +1382,7 @@ assign_attribute_or_color_locations(gl_shader_program *prog,
            ? "vertex shader input" : "fragment shader output";
 
         linker_error(prog,
-                     "insufficient contiguous attribute locations "
+                     "insufficient contiguous locations "
                      "available for %s `%s'",
                      string, to_assign[i].var->name);
         return false;
@@ -2169,7 +2212,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
     * of all shaders must match.
     */
    assert(min_version >= 100);
-   assert(max_version <= 130);
+   assert(max_version <= 140);
    if ((max_version >= 130 || min_version == 100)
        && min_version != max_version) {
       linker_error(prog, "all shaders must use same shading "
@@ -2263,7 +2306,9 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
       if (ctx->ShaderCompilerOptions[i].LowerClipDistance)
          lower_clip_distance(prog->_LinkedShaders[i]->ir);
 
-      while (do_common_optimization(prog->_LinkedShaders[i]->ir, true, false, 32))
+      unsigned max_unroll = ctx->ShaderCompilerOptions[i].MaxUnrollIterations;
+
+      while (do_common_optimization(prog->_LinkedShaders[i]->ir, true, false, max_unroll))
         ;
    }