src/mesa/main/shaderapi.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
   5  * Copyright (C) 2009-2010  VMware, Inc.  All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 /**
  27  * \file shaderapi.c
  28  * \author Brian Paul
  29  *
  30  * Implementation of GLSL-related API functions.
  31  * The glUniform* functions are in uniforms.c
  32  *
  33  *
  34  * XXX things to do:
  35  * 1. Check that the right error code is generated for all _mesa_error() calls.
  36  * 2. Insert FLUSH_VERTICES calls in various places
  37  */
  38
  39
  40 #include <stdbool.h>
  41 #include "main/glheader.h"
  42 #include "main/context.h"
  43 #include "main/dispatch.h"
  44 #include "main/enums.h"
  45 #include "main/hash.h"
  46 #include "main/mtypes.h"
  47 #include "main/pipelineobj.h"
  48 #include "main/shaderapi.h"
  49 #include "main/shaderobj.h"
  50 #include "main/transformfeedback.h"
  51 #include "main/uniforms.h"
  52 #include "glsl/glsl_parser_extras.h"
  53 #include "glsl/ir.h"
  54 #include "glsl/ir_uniform.h"
  55 #include "glsl/program.h"
  56 #include "program/program.h"
  57 #include "program/prog_print.h"
  58 #include "program/prog_parameter.h"
  59 #include "util/ralloc.h"
  60 #include "util/hash_table.h"
  61 #include "util/mesa-sha1.h"
  62
  63
  64 /**
  65  * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
  66  */
  67 GLbitfield
  68 _mesa_get_shader_flags(void)
  69 {
  70    GLbitfield flags = 0x0;
  71    const char *env = getenv("MESA_GLSL");
  72
  73    if (env) {
  74       if (strstr(env, "dump_on_error"))
  75          flags |= GLSL_DUMP_ON_ERROR;
  76       else if (strstr(env, "dump"))
  77          flags |= GLSL_DUMP;
  78       if (strstr(env, "log"))
  79          flags |= GLSL_LOG;
  80       if (strstr(env, "nopvert"))
  81          flags |= GLSL_NOP_VERT;
  82       if (strstr(env, "nopfrag"))
  83          flags |= GLSL_NOP_FRAG;
  84       if (strstr(env, "nopt"))
  85          flags |= GLSL_NO_OPT;
  86       else if (strstr(env, "opt"))
  87          flags |= GLSL_OPT;
  88       if (strstr(env, "uniform"))
  89          flags |= GLSL_UNIFORMS;
  90       if (strstr(env, "useprog"))
  91          flags |= GLSL_USE_PROG;
  92       if (strstr(env, "errors"))
  93          flags |= GLSL_REPORT_ERRORS;
  94    }
  95
  96    return flags;
  97 }
  98
  99
 100 /**
 101  * Initialize context's shader state.
 102  */
 103 void
 104 _mesa_init_shader_state(struct gl_context *ctx)
 105 {
 106    /* Device drivers may override these to control what kind of instructions
 107     * are generated by the GLSL compiler.
 108     */
 109    struct gl_shader_compiler_options options;
 110    gl_shader_stage sh;
 111    int i;
 112
 113    memset(&options, 0, sizeof(options));
 114    options.MaxUnrollIterations = 32;
 115    options.MaxIfDepth = UINT_MAX;
 116
 117    for (sh = 0; sh < MESA_SHADER_STAGES; ++sh)
 118       memcpy(&ctx->Const.ShaderCompilerOptions[sh], &options, sizeof(options));
 119
 120    ctx->Shader.Flags = _mesa_get_shader_flags();
 121
 122    if (ctx->Shader.Flags != 0)
 123       ctx->Const.GenerateTemporaryNames = true;
 124
 125    /* Extended for ARB_separate_shader_objects */
 126    ctx->Shader.RefCount = 1;
 127    mtx_init(&ctx->Shader.Mutex, mtx_plain);
 128
 129    ctx->TessCtrlProgram.patch_vertices = 3;
 130    for (i = 0; i < 4; ++i)
 131       ctx->TessCtrlProgram.patch_default_outer_level[i] = 1.0;
 132    for (i = 0; i < 2; ++i)
 133       ctx->TessCtrlProgram.patch_default_inner_level[i] = 1.0;
 134 }
 135
 136
 137 /**
 138  * Free the per-context shader-related state.
 139  */
 140 void
 141 _mesa_free_shader_state(struct gl_context *ctx)
 142 {
 143    int i;
 144    for (i = 0; i < MESA_SHADER_STAGES; i++) {
 145       _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram[i],
 146                                      NULL);
 147    }
 148    _mesa_reference_shader_program(ctx, &ctx->Shader._CurrentFragmentProgram,
 149                                   NULL);
 150    _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL);
 151
 152    /* Extended for ARB_separate_shader_objects */
 153    _mesa_reference_pipeline_object(ctx, &ctx->_Shader, NULL);
 154
 155    assert(ctx->Shader.RefCount == 1);
 156    mtx_destroy(&ctx->Shader.Mutex);
 157 }
 158
 159
 160 /**
 161  * Copy string from <src> to <dst>, up to maxLength characters, returning
 162  * length of <dst> in <length>.
 163  * \param src  the strings source
 164  * \param maxLength  max chars to copy
 165  * \param length  returns number of chars copied
 166  * \param dst  the string destination
 167  */
 168 void
 169 _mesa_copy_string(GLchar *dst, GLsizei maxLength,
 170                   GLsizei *length, const GLchar *src)
 171 {
 172    GLsizei len;
 173    for (len = 0; len < maxLength - 1 && src && src[len]; len++)
 174       dst[len] = src[len];
 175    if (maxLength > 0)
 176       dst[len] = 0;
 177    if (length)
 178       *length = len;
 179 }
 180
 181
 182
 183 /**
 184  * Confirm that the a shader type is valid and supported by the implementation
 185  *
 186  * \param ctx   Current GL context
 187  * \param type  Shader target
 188  *
 189  */
 190 bool
 191 _mesa_validate_shader_target(const struct gl_context *ctx, GLenum type)
 192 {
 193    /* Note: when building built-in GLSL functions, this function may be
 194     * invoked with ctx == NULL.  In that case, we can only validate that it's
 195     * a shader target we recognize, not that it's supported in the current
 196     * context.  But that's fine--we don't need any further validation than
 197     * that when building built-in GLSL functions.
 198     */
 199
 200    switch (type) {
 201    case GL_FRAGMENT_SHADER:
 202       return ctx == NULL || ctx->Extensions.ARB_fragment_shader;
 203    case GL_VERTEX_SHADER:
 204       return ctx == NULL || ctx->Extensions.ARB_vertex_shader;
 205    case GL_GEOMETRY_SHADER_ARB:
 206       return ctx == NULL || _mesa_has_geometry_shaders(ctx);
 207    case GL_TESS_CONTROL_SHADER:
 208    case GL_TESS_EVALUATION_SHADER:
 209       return ctx == NULL || _mesa_has_tessellation(ctx);
 210    case GL_COMPUTE_SHADER:
 211       return ctx == NULL || _mesa_has_compute_shaders(ctx);
 212    default:
 213       return false;
 214    }
 215 }
 216
 217
 218 static GLboolean
 219 is_program(struct gl_context *ctx, GLuint name)
 220 {
 221    struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
 222    return shProg ? GL_TRUE : GL_FALSE;
 223 }
 224
 225
 226 static GLboolean
 227 is_shader(struct gl_context *ctx, GLuint name)
 228 {
 229    struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
 230    return shader ? GL_TRUE : GL_FALSE;
 231 }
 232
 233
 234 /**
 235  * Attach shader to a shader program.
 236  */
 237 static void
 238 attach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
 239 {
 240    struct gl_shader_program *shProg;
 241    struct gl_shader *sh;
 242    GLuint i, n;
 243
 244    const bool same_type_disallowed = _mesa_is_gles(ctx);
 245
 246    shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");
 247    if (!shProg)
 248       return;
 249
 250    sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");
 251    if (!sh) {
 252       return;
 253    }
 254
 255    n = shProg->NumShaders;
 256    for (i = 0; i < n; i++) {
 257       if (shProg->Shaders[i] == sh) {
 258          /* The shader is already attched to this program.  The
 259           * GL_ARB_shader_objects spec says:
 260           *
 261           *     "The error INVALID_OPERATION is generated by AttachObjectARB
 262           *     if <obj> is already attached to <containerObj>."
 263           */
 264          _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");
 265          return;
 266       } else if (same_type_disallowed &&
 267                  shProg->Shaders[i]->Type == sh->Type) {
 268         /* Shader with the same type is already attached to this program,
 269          * OpenGL ES 2.0 and 3.0 specs say:
 270          *
 271          *      "Multiple shader objects of the same type may not be attached
 272          *      to a single program object. [...] The error INVALID_OPERATION
 273          *      is generated if [...] another shader object of the same type
 274          *      as shader is already attached to program."
 275          */
 276          _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");
 277          return;
 278       }
 279    }
 280
 281    /* grow list */
 282    shProg->Shaders = realloc(shProg->Shaders,
 283                              (n + 1) * sizeof(struct gl_shader *));
 284    if (!shProg->Shaders) {
 285       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
 286       return;
 287    }
 288
 289    /* append */
 290    shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
 291    _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
 292    shProg->NumShaders++;
 293 }
 294
 295
 296 static GLuint
 297 create_shader(struct gl_context *ctx, GLenum type)
 298 {
 299    struct gl_shader *sh;
 300    GLuint name;
 301
 302    if (!_mesa_validate_shader_target(ctx, type)) {
 303       _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(%s)",
 304                   _mesa_enum_to_string(type));
 305       return 0;
 306    }
 307
 308    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 309    sh = ctx->Driver.NewShader(ctx, name, type);
 310    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);
 311
 312    return name;
 313 }
 314
 315
 316 static GLuint
 317 create_shader_program(struct gl_context *ctx)
 318 {
 319    GLuint name;
 320    struct gl_shader_program *shProg;
 321
 322    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 323
 324    shProg = _mesa_new_shader_program(name);
 325
 326    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);
 327
 328    assert(shProg->RefCount == 1);
 329
 330    return name;
 331 }
 332
 333
 334 /**
 335  * Delete a shader program.  Actually, just decrement the program's
 336  * reference count and mark it as DeletePending.
 337  * Used to implement glDeleteProgram() and glDeleteObjectARB().
 338  */
 339 static void
 340 delete_shader_program(struct gl_context *ctx, GLuint name)
 341 {
 342    /*
 343     * NOTE: deleting shaders/programs works a bit differently than
 344     * texture objects (and buffer objects, etc).  Shader/program
 345     * handles/IDs exist in the hash table until the object is really
 346     * deleted (refcount==0).  With texture objects, the handle/ID is
 347     * removed from the hash table in glDeleteTextures() while the tex
 348     * object itself might linger until its refcount goes to zero.
 349     */
 350    struct gl_shader_program *shProg;
 351
 352    shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
 353    if (!shProg)
 354       return;
 355
 356    if (!shProg->DeletePending) {
 357       shProg->DeletePending = GL_TRUE;
 358
 359       /* effectively, decr shProg's refcount */
 360       _mesa_reference_shader_program(ctx, &shProg, NULL);
 361    }
 362 }
 363
 364
 365 static void
 366 delete_shader(struct gl_context *ctx, GLuint shader)
 367 {
 368    struct gl_shader *sh;
 369
 370    sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
 371    if (!sh)
 372       return;
 373
 374    if (!sh->DeletePending) {
 375       sh->DeletePending = GL_TRUE;
 376
 377       /* effectively, decr sh's refcount */
 378       _mesa_reference_shader(ctx, &sh, NULL);
 379    }
 380 }
 381
 382
 383 static void
 384 detach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
 385 {
 386    struct gl_shader_program *shProg;
 387    GLuint n;
 388    GLuint i, j;
 389
 390    shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");
 391    if (!shProg)
 392       return;
 393
 394    n = shProg->NumShaders;
 395
 396    for (i = 0; i < n; i++) {
 397       if (shProg->Shaders[i]->Name == shader) {
 398          /* found it */
 399          struct gl_shader **newList;
 400
 401          /* release */
 402          _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
 403
 404          /* alloc new, smaller array */
 405          newList = malloc((n - 1) * sizeof(struct gl_shader *));
 406          if (!newList) {
 407             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
 408             return;
 409          }
 410          /* Copy old list entries to new list, skipping removed entry at [i] */
 411          for (j = 0; j < i; j++) {
 412             newList[j] = shProg->Shaders[j];
 413          }
 414          while (++i < n) {
 415             newList[j++] = shProg->Shaders[i];
 416          }
 417
 418          /* Free old list and install new one */
 419          free(shProg->Shaders);
 420          shProg->Shaders = newList;
 421          shProg->NumShaders = n - 1;
 422
 423 #ifdef DEBUG
 424          /* sanity check - make sure the new list's entries are sensible */
 425          for (j = 0; j < shProg->NumShaders; j++) {
 426             assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||
 427                    shProg->Shaders[j]->Type == GL_TESS_CONTROL_SHADER ||
 428                    shProg->Shaders[j]->Type == GL_TESS_EVALUATION_SHADER ||
 429                    shProg->Shaders[j]->Type == GL_GEOMETRY_SHADER ||
 430                    shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);
 431             assert(shProg->Shaders[j]->RefCount > 0);
 432          }
 433 #endif
 434
 435          return;
 436       }
 437    }
 438
 439    /* not found */
 440    {
 441       GLenum err;
 442       if (is_shader(ctx, shader) || is_program(ctx, shader))
 443          err = GL_INVALID_OPERATION;
 444       else
 445          err = GL_INVALID_VALUE;
 446       _mesa_error(ctx, err, "glDetachShader(shader)");
 447       return;
 448    }
 449 }
 450
 451
 452 /**
 453  * Return list of shaders attached to shader program.
 454  */
 455 static void
 456 get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount,
 457                      GLsizei *count, GLuint *obj)
 458 {
 459    struct gl_shader_program *shProg;
 460
 461    if (maxCount < 0) {
 462       _mesa_error(ctx, GL_INVALID_VALUE, "glGetAttachedShaders(maxCount < 0)");
 463       return;
 464    }
 465
 466    shProg =
 467       _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");
 468
 469    if (shProg) {
 470       GLuint i;
 471       for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {
 472          obj[i] = shProg->Shaders[i]->Name;
 473       }
 474       if (count)
 475          *count = i;
 476    }
 477 }
 478
 479
 480 /**
 481  * glGetHandleARB() - return ID/name of currently bound shader program.
 482  */
 483 static GLuint
 484 get_handle(struct gl_context *ctx, GLenum pname)
 485 {
 486    if (pname == GL_PROGRAM_OBJECT_ARB) {
 487       if (ctx->_Shader->ActiveProgram)
 488          return ctx->_Shader->ActiveProgram->Name;
 489       else
 490          return 0;
 491    }
 492    else {
 493       _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
 494       return 0;
 495    }
 496 }
 497
 498
 499 /**
 500  * Check if a geometry shader query is valid at this time.  If not, report an
 501  * error and return false.
 502  *
 503  * From GL 3.2 section 6.1.16 (Shader and Program Queries):
 504  *
 505  *     "If GEOMETRY_VERTICES_OUT, GEOMETRY_INPUT_TYPE, or GEOMETRY_OUTPUT_TYPE
 506  *     are queried for a program which has not been linked successfully, or
 507  *     which does not contain objects to form a geometry shader, then an
 508  *     INVALID_OPERATION error is generated."
 509  */
 510 static bool
 511 check_gs_query(struct gl_context *ctx, const struct gl_shader_program *shProg)
 512 {
 513    if (shProg->LinkStatus &&
 514        shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] != NULL) {
 515       return true;
 516    }
 517
 518    _mesa_error(ctx, GL_INVALID_OPERATION,
 519                "glGetProgramv(linked geometry shader required)");
 520    return false;
 521 }
 522
 523
 524 /**
 525  * Check if a tessellation control shader query is valid at this time.
 526  * If not, report an error and return false.
 527  *
 528  * From GL 4.0 section 6.1.12 (Shader and Program Queries):
 529  *
 530  *     "If TESS_CONTROL_OUTPUT_VERTICES is queried for a program which has
 531  *     not been linked successfully, or which does not contain objects to
 532  *     form a tessellation control shader, then an INVALID_OPERATION error is
 533  *     generated."
 534  */
 535 static bool
 536 check_tcs_query(struct gl_context *ctx, const struct gl_shader_program *shProg)
 537 {
 538    if (shProg->LinkStatus &&
 539        shProg->_LinkedShaders[MESA_SHADER_TESS_CTRL] != NULL) {
 540       return true;
 541    }
 542
 543    _mesa_error(ctx, GL_INVALID_OPERATION,
 544                "glGetProgramv(linked tessellation control shader required)");
 545    return false;
 546 }
 547
 548
 549 /**
 550  * Check if a tessellation evaluation shader query is valid at this time.
 551  * If not, report an error and return false.
 552  *
 553  * From GL 4.0 section 6.1.12 (Shader and Program Queries):
 554  *
 555  *     "If any of the pname values in this paragraph are queried for a program
 556  *     which has not been linked successfully, or which does not contain
 557  *     objects to form a tessellation evaluation shader, then an
 558  *     INVALID_OPERATION error is generated."
 559  *
 560  */
 561 static bool
 562 check_tes_query(struct gl_context *ctx, const struct gl_shader_program *shProg)
 563 {
 564    if (shProg->LinkStatus &&
 565        shProg->_LinkedShaders[MESA_SHADER_TESS_EVAL] != NULL) {
 566       return true;
 567    }
 568
 569    _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramv(linked tessellation "
 570                "evaluation shader required)");
 571    return false;
 572 }
 573
 574
 575 /**
 576  * glGetProgramiv() - get shader program state.
 577  * Note that this is for GLSL shader programs, not ARB vertex/fragment
 578  * programs (see glGetProgramivARB).
 579  */
 580 static void
 581 get_programiv(struct gl_context *ctx, GLuint program, GLenum pname,
 582               GLint *params)
 583 {
 584    struct gl_shader_program *shProg
 585       = _mesa_lookup_shader_program_err(ctx, program, "glGetProgramiv(program)");
 586
 587    /* Is transform feedback available in this context?
 588     */
 589    const bool has_xfb =
 590       (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.EXT_transform_feedback)
 591       || ctx->API == API_OPENGL_CORE
 592       || _mesa_is_gles3(ctx);
 593
 594    /* True if geometry shaders (of the form that was adopted into GLSL 1.50
 595     * and GL 3.2) are available in this context
 596     */
 597    const bool has_core_gs = _mesa_has_geometry_shaders(ctx);
 598    const bool has_tess = _mesa_has_tessellation(ctx);
 599
 600    /* Are uniform buffer objects available in this context?
 601     */
 602    const bool has_ubo =
 603       (ctx->API == API_OPENGL_COMPAT &&
 604        ctx->Extensions.ARB_uniform_buffer_object)
 605       || ctx->API == API_OPENGL_CORE
 606       || _mesa_is_gles3(ctx);
 607
 608    if (!shProg) {
 609       return;
 610    }
 611
 612    switch (pname) {
 613    case GL_DELETE_STATUS:
 614       *params = shProg->DeletePending;
 615       return;
 616    case GL_LINK_STATUS:
 617       *params = shProg->LinkStatus;
 618       return;
 619    case GL_VALIDATE_STATUS:
 620       *params = shProg->Validated;
 621       return;
 622    case GL_INFO_LOG_LENGTH:
 623       *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
 624       return;
 625    case GL_ATTACHED_SHADERS:
 626       *params = shProg->NumShaders;
 627       return;
 628    case GL_ACTIVE_ATTRIBUTES:
 629       *params = _mesa_count_active_attribs(shProg);
 630       return;
 631    case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
 632       *params = _mesa_longest_attribute_name_length(shProg);
 633       return;
 634    case GL_ACTIVE_UNIFORMS: {
 635       unsigned i;
 636       const unsigned num_uniforms =
 637          shProg->NumUniformStorage - shProg->NumHiddenUniforms;
 638       for (*params = 0, i = 0; i < num_uniforms; i++) {
 639          if (!shProg->UniformStorage[i].is_shader_storage)
 640             (*params)++;
 641       }
 642       return;
 643    }
 644    case GL_ACTIVE_UNIFORM_MAX_LENGTH: {
 645       unsigned i;
 646       GLint max_len = 0;
 647       const unsigned num_uniforms =
 648          shProg->NumUniformStorage - shProg->NumHiddenUniforms;
 649
 650       for (i = 0; i < num_uniforms; i++) {
 651          if (shProg->UniformStorage[i].is_shader_storage)
 652             continue;
 653
 654          /* Add one for the terminating NUL character for a non-array, and
 655           * 4 for the "[0]" and the NUL for an array.
 656           */
 657          const GLint len = strlen(shProg->UniformStorage[i].name) + 1 +
 658              ((shProg->UniformStorage[i].array_elements != 0) ? 3 : 0);
 659
 660          if (len > max_len)
 661             max_len = len;
 662       }
 663
 664       *params = max_len;
 665       return;
 666    }
 667    case GL_TRANSFORM_FEEDBACK_VARYINGS:
 668       if (!has_xfb)
 669          break;
 670       *params = shProg->TransformFeedback.NumVarying;
 671       return;
 672    case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: {
 673       unsigned i;
 674       GLint max_len = 0;
 675       if (!has_xfb)
 676          break;
 677
 678       for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
 679          /* Add one for the terminating NUL character.
 680           */
 681          const GLint len =
 682             strlen(shProg->TransformFeedback.VaryingNames[i]) + 1;
 683
 684          if (len > max_len)
 685             max_len = len;
 686       }
 687
 688       *params = max_len;
 689       return;
 690    }
 691    case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
 692       if (!has_xfb)
 693          break;
 694       *params = shProg->TransformFeedback.BufferMode;
 695       return;
 696    case GL_GEOMETRY_VERTICES_OUT:
 697       if (!has_core_gs)
 698          break;
 699       if (check_gs_query(ctx, shProg))
 700          *params = shProg->Geom.VerticesOut;
 701       return;
 702    case GL_GEOMETRY_SHADER_INVOCATIONS:
 703       if (!has_core_gs || !ctx->Extensions.ARB_gpu_shader5)
 704          break;
 705       if (check_gs_query(ctx, shProg))
 706          *params = shProg->Geom.Invocations;
 707       return;
 708    case GL_GEOMETRY_INPUT_TYPE:
 709       if (!has_core_gs)
 710          break;
 711       if (check_gs_query(ctx, shProg))
 712          *params = shProg->Geom.InputType;
 713       return;
 714    case GL_GEOMETRY_OUTPUT_TYPE:
 715       if (!has_core_gs)
 716          break;
 717       if (check_gs_query(ctx, shProg))
 718          *params = shProg->Geom.OutputType;
 719       return;
 720    case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: {
 721       unsigned i;
 722       GLint max_len = 0;
 723
 724       if (!has_ubo)
 725          break;
 726
 727       for (i = 0; i < shProg->NumUniformBlocks; i++) {
 728          /* Add one for the terminating NUL character.
 729           */
 730          const GLint len = strlen(shProg->UniformBlocks[i]->Name) + 1;
 731
 732          if (len > max_len)
 733             max_len = len;
 734       }
 735
 736       *params = max_len;
 737       return;
 738    }
 739    case GL_ACTIVE_UNIFORM_BLOCKS:
 740       if (!has_ubo)
 741          break;
 742
 743       *params = shProg->NumUniformBlocks;
 744       return;
 745    case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
 746       /* This enum isn't part of the OES extension for OpenGL ES 2.0.  It is
 747        * only available with desktop OpenGL 3.0+ with the
 748        * GL_ARB_get_program_binary extension or OpenGL ES 3.0.
 749        *
 750        * On desktop, we ignore the 3.0+ requirement because it is silly.
 751        */
 752       if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx))
 753          break;
 754
 755       *params = shProg->BinaryRetreivableHint;
 756       return;
 757    case GL_PROGRAM_BINARY_LENGTH:
 758       *params = 0;
 759       return;
 760    case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS:
 761       if (!ctx->Extensions.ARB_shader_atomic_counters)
 762          break;
 763
 764       *params = shProg->NumAtomicBuffers;
 765       return;
 766    case GL_COMPUTE_WORK_GROUP_SIZE: {
 767       int i;
 768       if (!_mesa_has_compute_shaders(ctx))
 769          break;
 770       if (!shProg->LinkStatus) {
 771          _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramiv(program not "
 772                      "linked)");
 773          return;
 774       }
 775       if (shProg->_LinkedShaders[MESA_SHADER_COMPUTE] == NULL) {
 776          _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramiv(no compute "
 777                      "shaders)");
 778          return;
 779       }
 780       for (i = 0; i < 3; i++)
 781          params[i] = shProg->Comp.LocalSize[i];
 782       return;
 783    }
 784    case GL_PROGRAM_SEPARABLE:
 785       /* If the program has not been linked, return initial value 0. */
 786       *params = (shProg->LinkStatus == GL_FALSE) ? 0 : shProg->SeparateShader;
 787       return;
 788
 789    /* ARB_tessellation_shader */
 790    case GL_TESS_CONTROL_OUTPUT_VERTICES:
 791       if (!has_tess)
 792          break;
 793       if (check_tcs_query(ctx, shProg))
 794          *params = shProg->TessCtrl.VerticesOut;
 795       return;
 796    case GL_TESS_GEN_MODE:
 797       if (!has_tess)
 798          break;
 799       if (check_tes_query(ctx, shProg))
 800          *params = shProg->TessEval.PrimitiveMode;
 801       return;
 802    case GL_TESS_GEN_SPACING:
 803       if (!has_tess)
 804          break;
 805       if (check_tes_query(ctx, shProg))
 806          *params = shProg->TessEval.Spacing;
 807       return;
 808    case GL_TESS_GEN_VERTEX_ORDER:
 809       if (!has_tess)
 810          break;
 811       if (check_tes_query(ctx, shProg))
 812          *params = shProg->TessEval.VertexOrder;
 813       return;
 814    case GL_TESS_GEN_POINT_MODE:
 815       if (!has_tess)
 816          break;
 817       if (check_tes_query(ctx, shProg))
 818          *params = shProg->TessEval.PointMode;
 819       return;
 820    default:
 821       break;
 822    }
 823
 824    _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname=%s)",
 825                _mesa_enum_to_string(pname));
 826 }
 827
 828
 829 /**
 830  * glGetShaderiv() - get GLSL shader state
 831  */
 832 static void
 833 get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)
 834 {
 835    struct gl_shader *shader =
 836       _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");
 837
 838    if (!shader) {
 839       return;
 840    }
 841
 842    switch (pname) {
 843    case GL_SHADER_TYPE:
 844       *params = shader->Type;
 845       break;
 846    case GL_DELETE_STATUS:
 847       *params = shader->DeletePending;
 848       break;
 849    case GL_COMPILE_STATUS:
 850       *params = shader->CompileStatus;
 851       break;
 852    case GL_INFO_LOG_LENGTH:
 853       *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
 854       break;
 855    case GL_SHADER_SOURCE_LENGTH:
 856       *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
 857       break;
 858    default:
 859       _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
 860       return;
 861    }
 862 }
 863
 864
 865 static void
 866 get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,
 867                      GLsizei *length, GLchar *infoLog)
 868 {
 869    struct gl_shader_program *shProg;
 870
 871    /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
 872     * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
 873     *
 874     *     "If a negative number is provided where an argument of type sizei or
 875     *     sizeiptr is specified, an INVALID_VALUE error is generated."
 876     */
 877    if (bufSize < 0) {
 878       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(bufSize < 0)");
 879       return;
 880    }
 881
 882    shProg = _mesa_lookup_shader_program_err(ctx, program,
 883                                             "glGetProgramInfoLog(program)");
 884    if (!shProg) {
 885       return;
 886    }
 887
 888    _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);
 889 }
 890
 891
 892 static void
 893 get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,
 894                     GLsizei *length, GLchar *infoLog)
 895 {
 896    struct gl_shader *sh;
 897
 898    /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
 899     * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
 900     *
 901     *     "If a negative number is provided where an argument of type sizei or
 902     *     sizeiptr is specified, an INVALID_VALUE error is generated."
 903     */
 904    if (bufSize < 0) {
 905       _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(bufSize < 0)");
 906       return;
 907    }
 908
 909    sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderInfoLog(shader)");
 910    if (!sh) {
 911       return;
 912    }
 913
 914    _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);
 915 }
 916
 917
 918 /**
 919  * Return shader source code.
 920  */
 921 static void
 922 get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,
 923                   GLsizei *length, GLchar *sourceOut)
 924 {
 925    struct gl_shader *sh;
 926
 927    if (maxLength < 0) {
 928       _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderSource(bufSize < 0)");
 929       return;
 930    }
 931
 932    sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
 933    if (!sh) {
 934       return;
 935    }
 936    _mesa_copy_string(sourceOut, maxLength, length, sh->Source);
 937 }
 938
 939
 940 /**
 941  * Set/replace shader source code.  A helper function used by
 942  * glShaderSource[ARB].
 943  */
 944 static void
 945 shader_source(struct gl_shader *sh, const GLchar *source)
 946 {
 947    assert(sh);
 948
 949    /* free old shader source string and install new one */
 950    free((void *)sh->Source);
 951    sh->Source = source;
 952    sh->CompileStatus = GL_FALSE;
 953 #ifdef DEBUG
 954    sh->SourceChecksum = _mesa_str_checksum(sh->Source);
 955 #endif
 956 }
 957
 958
 959 /**
 960  * Compile a shader.
 961  */
 962 static void
 963 compile_shader(struct gl_context *ctx, GLuint shaderObj)
 964 {
 965    struct gl_shader *sh;
 966
 967    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
 968    if (!sh)
 969       return;
 970
 971    if (!sh->Source) {
 972       /* If the user called glCompileShader without first calling
 973        * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
 974        */
 975       sh->CompileStatus = GL_FALSE;
 976    } else {
 977       if (ctx->_Shader->Flags & GLSL_DUMP) {
 978          _mesa_log("GLSL source for %s shader %d:\n",
 979                  _mesa_shader_stage_to_string(sh->Stage), sh->Name);
 980          _mesa_log("%s\n", sh->Source);
 981       }
 982
 983       /* this call will set the shader->CompileStatus field to indicate if
 984        * compilation was successful.
 985        */
 986       _mesa_glsl_compile_shader(ctx, sh, false, false);
 987
 988       if (ctx->_Shader->Flags & GLSL_LOG) {
 989          _mesa_write_shader_to_file(sh);
 990       }
 991
 992       if (ctx->_Shader->Flags & GLSL_DUMP) {
 993          if (sh->CompileStatus) {
 994             _mesa_log("GLSL IR for shader %d:\n", sh->Name);
 995             _mesa_print_ir(_mesa_get_log_file(), sh->ir, NULL);
 996             _mesa_log("\n\n");
 997          } else {
 998             _mesa_log("GLSL shader %d failed to compile.\n", sh->Name);
 999          }
1000          if (sh->InfoLog && sh->InfoLog[0] != 0) {
1001             _mesa_log("GLSL shader %d info log:\n", sh->Name);
1002             _mesa_log("%s\n", sh->InfoLog);
1003          }
1004       }
1005    }
1006
1007    if (!sh->CompileStatus) {
1008       if (ctx->_Shader->Flags & GLSL_DUMP_ON_ERROR) {
1009          _mesa_log("GLSL source for %s shader %d:\n",
1010                  _mesa_shader_stage_to_string(sh->Stage), sh->Name);
1011          _mesa_log("%s\n", sh->Source);
1012          _mesa_log("Info Log:\n%s\n", sh->InfoLog);
1013       }
1014
1015       if (ctx->_Shader->Flags & GLSL_REPORT_ERRORS) {
1016          _mesa_debug(ctx, "Error compiling shader %u:\n%s\n",
1017                      sh->Name, sh->InfoLog);
1018       }
1019    }
1020 }
1021
1022
1023 /**
1024  * Link a program's shaders.
1025  */
1026 static void
1027 link_program(struct gl_context *ctx, GLuint program)
1028 {
1029    struct gl_shader_program *shProg;
1030
1031    shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
1032    if (!shProg)
1033       return;
1034
1035    /* From the ARB_transform_feedback2 specification:
1036     * "The error INVALID_OPERATION is generated by LinkProgram if <program> is
1037     *  the name of a program being used by one or more transform feedback
1038     *  objects, even if the objects are not currently bound or are paused."
1039     */
1040    if (_mesa_transform_feedback_is_using_program(ctx, shProg)) {
1041       _mesa_error(ctx, GL_INVALID_OPERATION,
1042                   "glLinkProgram(transform feedback is using the program)");
1043       return;
1044    }
1045
1046    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
1047
1048    _mesa_glsl_link_shader(ctx, shProg);
1049
1050    if (shProg->LinkStatus == GL_FALSE &&
1051        (ctx->_Shader->Flags & GLSL_REPORT_ERRORS)) {
1052       _mesa_debug(ctx, "Error linking program %u:\n%s\n",
1053                   shProg->Name, shProg->InfoLog);
1054    }
1055
1056    /* debug code */
1057    if (0) {
1058       GLuint i;
1059
1060       printf("Link %u shaders in program %u: %s\n",
1061                    shProg->NumShaders, shProg->Name,
1062                    shProg->LinkStatus ? "Success" : "Failed");
1063
1064       for (i = 0; i < shProg->NumShaders; i++) {
1065          printf(" shader %u, type 0x%x\n",
1066                       shProg->Shaders[i]->Name,
1067                       shProg->Shaders[i]->Type);
1068       }
1069    }
1070 }
1071
1072
1073 /**
1074  * Print basic shader info (for debug).
1075  */
1076 static void
1077 print_shader_info(const struct gl_shader_program *shProg)
1078 {
1079    GLuint i;
1080
1081    printf("Mesa: glUseProgram(%u)\n", shProg->Name);
1082    for (i = 0; i < shProg->NumShaders; i++) {
1083       printf("  %s shader %u, checksum %u\n",
1084              _mesa_shader_stage_to_string(shProg->Shaders[i]->Stage),
1085              shProg->Shaders[i]->Name,
1086              shProg->Shaders[i]->SourceChecksum);
1087    }
1088    if (shProg->_LinkedShaders[MESA_SHADER_VERTEX])
1089       printf("  vert prog %u\n",
1090              shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program->Id);
1091    if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT])
1092       printf("  frag prog %u\n",
1093              shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program->Id);
1094    if (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY])
1095       printf("  geom prog %u\n",
1096              shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program->Id);
1097    if (shProg->_LinkedShaders[MESA_SHADER_TESS_CTRL])
1098       printf("  tesc prog %u\n",
1099              shProg->_LinkedShaders[MESA_SHADER_TESS_CTRL]->Program->Id);
1100    if (shProg->_LinkedShaders[MESA_SHADER_TESS_EVAL])
1101       printf("  tese prog %u\n",
1102              shProg->_LinkedShaders[MESA_SHADER_TESS_EVAL]->Program->Id);
1103 }
1104
1105
1106 /**
1107  * Use the named shader program for subsequent glUniform calls
1108  */
1109 void
1110 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
1111                      const char *caller)
1112 {
1113    if ((shProg != NULL) && !shProg->LinkStatus) {
1114       _mesa_error(ctx, GL_INVALID_OPERATION,
1115                   "%s(program %u not linked)", caller, shProg->Name);
1116       return;
1117    }
1118
1119    if (ctx->Shader.ActiveProgram != shProg) {
1120       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
1121    }
1122 }
1123
1124
1125 static void
1126 use_shader_program(struct gl_context *ctx, gl_shader_stage stage,
1127                    struct gl_shader_program *shProg,
1128                    struct gl_pipeline_object *shTarget)
1129 {
1130    struct gl_shader_program **target;
1131
1132    target = &shTarget->CurrentProgram[stage];
1133    if ((shProg != NULL) && (shProg->_LinkedShaders[stage] == NULL))
1134       shProg = NULL;
1135
1136    if (*target != shProg) {
1137       /* Program is current, flush it */
1138       if (shTarget == ctx->_Shader) {
1139          FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
1140       }
1141
1142       /* If the shader is also bound as the current rendering shader, unbind
1143        * it from that binding point as well.  This ensures that the correct
1144        * semantics of glDeleteProgram are maintained.
1145        */
1146       switch (stage) {
1147       case MESA_SHADER_VERTEX:
1148       case MESA_SHADER_TESS_CTRL:
1149       case MESA_SHADER_TESS_EVAL:
1150       case MESA_SHADER_GEOMETRY:
1151       case MESA_SHADER_COMPUTE:
1152          /* Empty for now. */
1153          break;
1154       case MESA_SHADER_FRAGMENT:
1155          if (*target == ctx->_Shader->_CurrentFragmentProgram) {
1156             _mesa_reference_shader_program(ctx,
1157                                            &ctx->_Shader->_CurrentFragmentProgram,
1158                                            NULL);
1159          }
1160          break;
1161       }
1162
1163       _mesa_reference_shader_program(ctx, target, shProg);
1164       return;
1165    }
1166 }
1167
1168
1169 /**
1170  * Use the named shader program for subsequent rendering.
1171  */
1172 void
1173 _mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
1174 {
1175    int i;
1176    for (i = 0; i < MESA_SHADER_STAGES; i++)
1177       use_shader_program(ctx, i, shProg, &ctx->Shader);
1178    _mesa_active_program(ctx, shProg, "glUseProgram");
1179
1180    _mesa_shader_program_init_subroutine_defaults(shProg);
1181    if (ctx->Driver.UseProgram)
1182       ctx->Driver.UseProgram(ctx, shProg);
1183 }
1184
1185
1186 /**
1187  * Do validation of the given shader program.
1188  * \param errMsg  returns error message if validation fails.
1189  * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1190  */
1191 static GLboolean
1192 validate_shader_program(const struct gl_shader_program *shProg,
1193                         char *errMsg)
1194 {
1195    if (!shProg->LinkStatus) {
1196       return GL_FALSE;
1197    }
1198
1199    /* From the GL spec, a program is invalid if any of these are true:
1200
1201      any two active samplers in the current program object are of
1202      different types, but refer to the same texture image unit,
1203
1204      any active sampler in the current program object refers to a texture
1205      image unit where fixed-function fragment processing accesses a
1206      texture target that does not match the sampler type, or
1207
1208      the sum of the number of active samplers in the program and the
1209      number of texture image units enabled for fixed-function fragment
1210      processing exceeds the combined limit on the total number of texture
1211      image units allowed.
1212    */
1213
1214    /*
1215     * Check: any two active samplers in the current program object are of
1216     * different types, but refer to the same texture image unit,
1217     */
1218    if (!_mesa_sampler_uniforms_are_valid(shProg, errMsg, 100))
1219       return GL_FALSE;
1220
1221    return GL_TRUE;
1222 }
1223
1224
1225 /**
1226  * Called via glValidateProgram()
1227  */
1228 static void
1229 validate_program(struct gl_context *ctx, GLuint program)
1230 {
1231    struct gl_shader_program *shProg;
1232    char errMsg[100] = "";
1233
1234    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1235    if (!shProg) {
1236       return;
1237    }
1238
1239    shProg->Validated = validate_shader_program(shProg, errMsg);
1240    if (!shProg->Validated) {
1241       /* update info log */
1242       if (shProg->InfoLog) {
1243          ralloc_free(shProg->InfoLog);
1244       }
1245       shProg->InfoLog = ralloc_strdup(shProg, errMsg);
1246    }
1247 }
1248
1249
1250
1251 void GLAPIENTRY
1252 _mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
1253 {
1254    GET_CURRENT_CONTEXT(ctx);
1255    attach_shader(ctx, program, shader);
1256 }
1257
1258
1259 void GLAPIENTRY
1260 _mesa_AttachShader(GLuint program, GLuint shader)
1261 {
1262    GET_CURRENT_CONTEXT(ctx);
1263    attach_shader(ctx, program, shader);
1264 }
1265
1266
1267 void GLAPIENTRY
1268 _mesa_CompileShader(GLhandleARB shaderObj)
1269 {
1270    GET_CURRENT_CONTEXT(ctx);
1271    if (MESA_VERBOSE & VERBOSE_API)
1272       _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
1273    compile_shader(ctx, shaderObj);
1274 }
1275
1276
1277 GLuint GLAPIENTRY
1278 _mesa_CreateShader(GLenum type)
1279 {
1280    GET_CURRENT_CONTEXT(ctx);
1281    if (MESA_VERBOSE & VERBOSE_API)
1282       _mesa_debug(ctx, "glCreateShader %s\n", _mesa_enum_to_string(type));
1283    return create_shader(ctx, type);
1284 }
1285
1286
1287 GLhandleARB GLAPIENTRY
1288 _mesa_CreateShaderObjectARB(GLenum type)
1289 {
1290    GET_CURRENT_CONTEXT(ctx);
1291    return create_shader(ctx, type);
1292 }
1293
1294
1295 GLuint GLAPIENTRY
1296 _mesa_CreateProgram(void)
1297 {
1298    GET_CURRENT_CONTEXT(ctx);
1299    if (MESA_VERBOSE & VERBOSE_API)
1300       _mesa_debug(ctx, "glCreateProgram\n");
1301    return create_shader_program(ctx);
1302 }
1303
1304
1305 GLhandleARB GLAPIENTRY
1306 _mesa_CreateProgramObjectARB(void)
1307 {
1308    GET_CURRENT_CONTEXT(ctx);
1309    return create_shader_program(ctx);
1310 }
1311
1312
1313 void GLAPIENTRY
1314 _mesa_DeleteObjectARB(GLhandleARB obj)
1315 {
1316    if (MESA_VERBOSE & VERBOSE_API) {
1317       GET_CURRENT_CONTEXT(ctx);
1318       _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);
1319    }
1320
1321    if (obj) {
1322       GET_CURRENT_CONTEXT(ctx);
1323       FLUSH_VERTICES(ctx, 0);
1324       if (is_program(ctx, obj)) {
1325          delete_shader_program(ctx, obj);
1326       }
1327       else if (is_shader(ctx, obj)) {
1328          delete_shader(ctx, obj);
1329       }
1330       else {
1331          /* error? */
1332       }
1333    }
1334 }
1335
1336
1337 void GLAPIENTRY
1338 _mesa_DeleteProgram(GLuint name)
1339 {
1340    if (name) {
1341       GET_CURRENT_CONTEXT(ctx);
1342       FLUSH_VERTICES(ctx, 0);
1343       delete_shader_program(ctx, name);
1344    }
1345 }
1346
1347
1348 void GLAPIENTRY
1349 _mesa_DeleteShader(GLuint name)
1350 {
1351    if (name) {
1352       GET_CURRENT_CONTEXT(ctx);
1353       FLUSH_VERTICES(ctx, 0);
1354       delete_shader(ctx, name);
1355    }
1356 }
1357
1358
1359 void GLAPIENTRY
1360 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
1361 {
1362    GET_CURRENT_CONTEXT(ctx);
1363    detach_shader(ctx, program, shader);
1364 }
1365
1366
1367 void GLAPIENTRY
1368 _mesa_DetachShader(GLuint program, GLuint shader)
1369 {
1370    GET_CURRENT_CONTEXT(ctx);
1371    detach_shader(ctx, program, shader);
1372 }
1373
1374
1375 void GLAPIENTRY
1376 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
1377                             GLsizei * count, GLhandleARB * obj)
1378 {
1379    GET_CURRENT_CONTEXT(ctx);
1380    get_attached_shaders(ctx, container, maxCount, count, obj);
1381 }
1382
1383
1384 void GLAPIENTRY
1385 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
1386                          GLsizei *count, GLuint *obj)
1387 {
1388    GET_CURRENT_CONTEXT(ctx);
1389    get_attached_shaders(ctx, program, maxCount, count, obj);
1390 }
1391
1392
1393 void GLAPIENTRY
1394 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
1395                     GLcharARB * infoLog)
1396 {
1397    GET_CURRENT_CONTEXT(ctx);
1398    if (is_program(ctx, object)) {
1399       get_program_info_log(ctx, object, maxLength, length, infoLog);
1400    }
1401    else if (is_shader(ctx, object)) {
1402       get_shader_info_log(ctx, object, maxLength, length, infoLog);
1403    }
1404    else {
1405       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1406    }
1407 }
1408
1409
1410 void GLAPIENTRY
1411 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
1412 {
1413    GET_CURRENT_CONTEXT(ctx);
1414    /* Implement in terms of GetProgramiv, GetShaderiv */
1415    if (is_program(ctx, object)) {
1416       if (pname == GL_OBJECT_TYPE_ARB) {
1417          *params = GL_PROGRAM_OBJECT_ARB;
1418       }
1419       else {
1420          get_programiv(ctx, object, pname, params);
1421       }
1422    }
1423    else if (is_shader(ctx, object)) {
1424       if (pname == GL_OBJECT_TYPE_ARB) {
1425          *params = GL_SHADER_OBJECT_ARB;
1426       }
1427       else {
1428          get_shaderiv(ctx, object, pname, params);
1429       }
1430    }
1431    else {
1432       _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1433    }
1434 }
1435
1436
1437 void GLAPIENTRY
1438 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
1439                               GLfloat *params)
1440 {
1441    GLint iparams[1] = {0};  /* XXX is one element enough? */
1442    _mesa_GetObjectParameterivARB(object, pname, iparams);
1443    params[0] = (GLfloat) iparams[0];
1444 }
1445
1446
1447 void GLAPIENTRY
1448 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
1449 {
1450    GET_CURRENT_CONTEXT(ctx);
1451    get_programiv(ctx, program, pname, params);
1452 }
1453
1454
1455 void GLAPIENTRY
1456 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
1457 {
1458    GET_CURRENT_CONTEXT(ctx);
1459    get_shaderiv(ctx, shader, pname, params);
1460 }
1461
1462
1463 void GLAPIENTRY
1464 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
1465                         GLsizei *length, GLchar *infoLog)
1466 {
1467    GET_CURRENT_CONTEXT(ctx);
1468    get_program_info_log(ctx, program, bufSize, length, infoLog);
1469 }
1470
1471
1472 void GLAPIENTRY
1473 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
1474                        GLsizei *length, GLchar *infoLog)
1475 {
1476    GET_CURRENT_CONTEXT(ctx);
1477    get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1478 }
1479
1480
1481 void GLAPIENTRY
1482 _mesa_GetShaderSource(GLhandleARB shader, GLsizei maxLength,
1483                          GLsizei *length, GLcharARB *sourceOut)
1484 {
1485    GET_CURRENT_CONTEXT(ctx);
1486    get_shader_source(ctx, shader, maxLength, length, sourceOut);
1487 }
1488
1489
1490 GLhandleARB GLAPIENTRY
1491 _mesa_GetHandleARB(GLenum pname)
1492 {
1493    GET_CURRENT_CONTEXT(ctx);
1494    return get_handle(ctx, pname);
1495 }
1496
1497
1498 GLboolean GLAPIENTRY
1499 _mesa_IsProgram(GLuint name)
1500 {
1501    GET_CURRENT_CONTEXT(ctx);
1502    return is_program(ctx, name);
1503 }
1504
1505
1506 GLboolean GLAPIENTRY
1507 _mesa_IsShader(GLuint name)
1508 {
1509    GET_CURRENT_CONTEXT(ctx);
1510    return is_shader(ctx, name);
1511 }
1512
1513
1514 void GLAPIENTRY
1515 _mesa_LinkProgram(GLhandleARB programObj)
1516 {
1517    GET_CURRENT_CONTEXT(ctx);
1518    if (MESA_VERBOSE & VERBOSE_API)
1519       _mesa_debug(ctx, "glLinkProgram %u\n", programObj);
1520    link_program(ctx, programObj);
1521 }
1522
1523 #if defined(HAVE_SHA1)
1524 /**
1525  * Generate a SHA-1 hash value string for given source string.
1526  */
1527 static void
1528 generate_sha1(const char *source, char sha_str[64])
1529 {
1530    unsigned char sha[20];
1531    _mesa_sha1_compute(source, strlen(source), sha);
1532    _mesa_sha1_format(sha_str, sha);
1533 }
1534
1535 /**
1536  * Construct a full path for shader replacement functionality using
1537  * following format:
1538  *
1539  * <path>/<stage prefix>_<CHECKSUM>.glsl
1540  */
1541 static void
1542 construct_name(const gl_shader_stage stage, const char *source,
1543                const char *path, char *name, unsigned length)
1544 {
1545    char sha[64];
1546    static const char *types[] = {
1547       "VS", "TC", "TE", "GS", "FS", "CS",
1548    };
1549
1550    generate_sha1(source, sha);
1551    _mesa_snprintf(name, length, "%s/%s_%s.glsl", path, types[stage],
1552                   sha);
1553 }
1554
1555 /**
1556  * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1557  */
1558 static void
1559 dump_shader(const gl_shader_stage stage, const char *source)
1560 {
1561    char name[PATH_MAX];
1562    static bool path_exists = true;
1563    char *dump_path;
1564    FILE *f;
1565
1566    if (!path_exists)
1567       return;
1568
1569    dump_path = getenv("MESA_SHADER_DUMP_PATH");
1570    if (!dump_path) {
1571       path_exists = false;
1572       return;
1573    }
1574
1575    construct_name(stage, source, dump_path, name, PATH_MAX);
1576
1577    f = fopen(name, "w");
1578    if (f) {
1579       fputs(source, f);
1580       fclose(f);
1581    } else {
1582       GET_CURRENT_CONTEXT(ctx);
1583       _mesa_warning(ctx, "could not open %s for dumping shader (%s)", name,
1584                     strerror(errno));
1585    }
1586 }
1587
1588 /**
1589  * Read shader source code from a file.
1590  * Useful for debugging to override an app's shader.
1591  */
1592 static GLcharARB *
1593 read_shader(const gl_shader_stage stage, const char *source)
1594 {
1595    char name[PATH_MAX];
1596    char *read_path;
1597    static bool path_exists = true;
1598    int len, shader_size = 0;
1599    GLcharARB *buffer;
1600    FILE *f;
1601
1602    if (!path_exists)
1603       return NULL;
1604
1605    read_path = getenv("MESA_SHADER_READ_PATH");
1606    if (!read_path) {
1607       path_exists = false;
1608       return NULL;
1609    }
1610
1611    construct_name(stage, source, read_path, name, PATH_MAX);
1612
1613    f = fopen(name, "r");
1614    if (!f)
1615       return NULL;
1616
1617    /* allocate enough room for the entire shader */
1618    fseek(f, 0, SEEK_END);
1619    shader_size = ftell(f);
1620    rewind(f);
1621    assert(shader_size);
1622
1623    /* add one for terminating zero */
1624    shader_size++;
1625
1626    buffer = malloc(shader_size);
1627    assert(buffer);
1628
1629    len = fread(buffer, 1, shader_size, f);
1630    buffer[len] = 0;
1631
1632    fclose(f);
1633
1634    return buffer;
1635 }
1636 #endif /* HAVE_SHA1 */
1637
1638 /**
1639  * Called via glShaderSource() and glShaderSourceARB() API functions.
1640  * Basically, concatenate the source code strings into one long string
1641  * and pass it to _mesa_shader_source().
1642  */
1643 void GLAPIENTRY
1644 _mesa_ShaderSource(GLhandleARB shaderObj, GLsizei count,
1645                    const GLcharARB * const * string, const GLint * length)
1646 {
1647    GET_CURRENT_CONTEXT(ctx);
1648    GLint *offsets;
1649    GLsizei i, totalLength;
1650    GLcharARB *source;
1651    struct gl_shader *sh;
1652
1653 #if defined(HAVE_SHA1)
1654    GLcharARB *replacement;
1655 #endif /* HAVE_SHA1 */
1656
1657    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glShaderSourceARB");
1658    if (!sh)
1659       return;
1660
1661    if (string == NULL) {
1662       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1663       return;
1664    }
1665
1666    /*
1667     * This array holds offsets of where the appropriate string ends, thus the
1668     * last element will be set to the total length of the source code.
1669     */
1670    offsets = malloc(count * sizeof(GLint));
1671    if (offsets == NULL) {
1672       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1673       return;
1674    }
1675
1676    for (i = 0; i < count; i++) {
1677       if (string[i] == NULL) {
1678          free((GLvoid *) offsets);
1679          _mesa_error(ctx, GL_INVALID_OPERATION,
1680                      "glShaderSourceARB(null string)");
1681          return;
1682       }
1683       if (length == NULL || length[i] < 0)
1684          offsets[i] = strlen(string[i]);
1685       else
1686          offsets[i] = length[i];
1687       /* accumulate string lengths */
1688       if (i > 0)
1689          offsets[i] += offsets[i - 1];
1690    }
1691
1692    /* Total length of source string is sum off all strings plus two.
1693     * One extra byte for terminating zero, another extra byte to silence
1694     * valgrind warnings in the parser/grammer code.
1695     */
1696    totalLength = offsets[count - 1] + 2;
1697    source = malloc(totalLength * sizeof(GLcharARB));
1698    if (source == NULL) {
1699       free((GLvoid *) offsets);
1700       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1701       return;
1702    }
1703
1704    for (i = 0; i < count; i++) {
1705       GLint start = (i > 0) ? offsets[i - 1] : 0;
1706       memcpy(source + start, string[i],
1707              (offsets[i] - start) * sizeof(GLcharARB));
1708    }
1709    source[totalLength - 1] = '\0';
1710    source[totalLength - 2] = '\0';
1711
1712 #if defined(HAVE_SHA1)
1713    /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
1714     * if corresponding entry found from MESA_SHADER_READ_PATH.
1715     */
1716    dump_shader(sh->Stage, source);
1717
1718    replacement = read_shader(sh->Stage, source);
1719    if (replacement) {
1720       free(source);
1721       source = replacement;
1722    }
1723 #endif /* HAVE_SHA1 */
1724
1725    shader_source(sh, source);
1726
1727    free(offsets);
1728 }
1729
1730
1731 void GLAPIENTRY
1732 _mesa_UseProgram(GLhandleARB program)
1733 {
1734    GET_CURRENT_CONTEXT(ctx);
1735    struct gl_shader_program *shProg;
1736
1737    if (MESA_VERBOSE & VERBOSE_API)
1738       _mesa_debug(ctx, "glUseProgram %u\n", program);
1739
1740    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1741       _mesa_error(ctx, GL_INVALID_OPERATION,
1742                   "glUseProgram(transform feedback active)");
1743       return;
1744    }
1745
1746    if (program) {
1747       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1748       if (!shProg) {
1749          return;
1750       }
1751       if (!shProg->LinkStatus) {
1752          _mesa_error(ctx, GL_INVALID_OPERATION,
1753                      "glUseProgram(program %u not linked)", program);
1754          return;
1755       }
1756
1757       /* debug code */
1758       if (ctx->_Shader->Flags & GLSL_USE_PROG) {
1759          print_shader_info(shProg);
1760       }
1761    }
1762    else {
1763       shProg = NULL;
1764    }
1765
1766    /* The ARB_separate_shader_object spec says:
1767     *
1768     *     "The executable code for an individual shader stage is taken from
1769     *     the current program for that stage.  If there is a current program
1770     *     object established by UseProgram, that program is considered current
1771     *     for all stages.  Otherwise, if there is a bound program pipeline
1772     *     object (section 2.14.PPO), the program bound to the appropriate
1773     *     stage of the pipeline object is considered current."
1774     */
1775    if (program) {
1776       /* Attach shader state to the binding point */
1777       _mesa_reference_pipeline_object(ctx, &ctx->_Shader, &ctx->Shader);
1778       /* Update the program */
1779       _mesa_use_program(ctx, shProg);
1780    } else {
1781       /* Must be done first: detach the progam */
1782       _mesa_use_program(ctx, shProg);
1783       /* Unattach shader_state binding point */
1784       _mesa_reference_pipeline_object(ctx, &ctx->_Shader, ctx->Pipeline.Default);
1785       /* If a pipeline was bound, rebind it */
1786       if (ctx->Pipeline.Current) {
1787          _mesa_BindProgramPipeline(ctx->Pipeline.Current->Name);
1788       }
1789    }
1790 }
1791
1792
1793 void GLAPIENTRY
1794 _mesa_ValidateProgram(GLhandleARB program)
1795 {
1796    GET_CURRENT_CONTEXT(ctx);
1797    validate_program(ctx, program);
1798 }
1799
1800
1801 /**
1802  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1803  */
1804 void GLAPIENTRY
1805 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1806                                GLint* range, GLint* precision)
1807 {
1808    const struct gl_program_constants *limits;
1809    const struct gl_precision *p;
1810    GET_CURRENT_CONTEXT(ctx);
1811
1812    switch (shadertype) {
1813    case GL_VERTEX_SHADER:
1814       limits = &ctx->Const.Program[MESA_SHADER_VERTEX];
1815       break;
1816    case GL_FRAGMENT_SHADER:
1817       limits = &ctx->Const.Program[MESA_SHADER_FRAGMENT];
1818       break;
1819    default:
1820       _mesa_error(ctx, GL_INVALID_ENUM,
1821                   "glGetShaderPrecisionFormat(shadertype)");
1822       return;
1823    }
1824
1825    switch (precisiontype) {
1826    case GL_LOW_FLOAT:
1827       p = &limits->LowFloat;
1828       break;
1829    case GL_MEDIUM_FLOAT:
1830       p = &limits->MediumFloat;
1831       break;
1832    case GL_HIGH_FLOAT:
1833       p = &limits->HighFloat;
1834       break;
1835    case GL_LOW_INT:
1836       p = &limits->LowInt;
1837       break;
1838    case GL_MEDIUM_INT:
1839       p = &limits->MediumInt;
1840       break;
1841    case GL_HIGH_INT:
1842       p = &limits->HighInt;
1843       break;
1844    default:
1845       _mesa_error(ctx, GL_INVALID_ENUM,
1846                   "glGetShaderPrecisionFormat(precisiontype)");
1847       return;
1848    }
1849
1850    range[0] = p->RangeMin;
1851    range[1] = p->RangeMax;
1852    precision[0] = p->Precision;
1853 }
1854
1855
1856 /**
1857  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1858  */
1859 void GLAPIENTRY
1860 _mesa_ReleaseShaderCompiler(void)
1861 {
1862    _mesa_destroy_shader_compiler_caches();
1863 }
1864
1865
1866 /**
1867  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1868  */
1869 void GLAPIENTRY
1870 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1871                    const void* binary, GLint length)
1872 {
1873    GET_CURRENT_CONTEXT(ctx);
1874    (void) shaders;
1875    (void) binaryformat;
1876    (void) binary;
1877
1878    /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
1879     * page 88 of the OpenGL 4.5 specs state:
1880     *
1881     *     "An INVALID_VALUE error is generated if count or length is negative.
1882     *      An INVALID_ENUM error is generated if binaryformat is not a supported
1883     *      format returned in SHADER_BINARY_FORMATS."
1884     */
1885    if (n < 0 || length < 0) {
1886       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderBinary(count or length < 0)");
1887       return;
1888    }
1889
1890    _mesa_error(ctx, GL_INVALID_ENUM, "glShaderBinary(format)");
1891 }
1892
1893
1894 void GLAPIENTRY
1895 _mesa_GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
1896                        GLenum *binaryFormat, GLvoid *binary)
1897 {
1898    struct gl_shader_program *shProg;
1899    GLsizei length_dummy;
1900    GET_CURRENT_CONTEXT(ctx);
1901
1902    if (bufSize < 0){
1903       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramBinary(bufSize < 0)");
1904       return;
1905    }
1906
1907    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetProgramBinary");
1908    if (!shProg)
1909       return;
1910
1911    /* The ARB_get_program_binary spec says:
1912     *
1913     *     "If <length> is NULL, then no length is returned."
1914     *
1915     * Ensure that length always points to valid storage to avoid multiple NULL
1916     * pointer checks below.
1917     */
1918    if (length == NULL)
1919       length = &length_dummy;
1920
1921
1922    /* The ARB_get_program_binary spec says:
1923     *
1924     *     "When a program object's LINK_STATUS is FALSE, its program binary
1925     *     length is zero, and a call to GetProgramBinary will generate an
1926     *     INVALID_OPERATION error.
1927     */
1928    if (!shProg->LinkStatus) {
1929       _mesa_error(ctx, GL_INVALID_OPERATION,
1930                   "glGetProgramBinary(program %u not linked)",
1931                   shProg->Name);
1932       *length = 0;
1933       return;
1934    }
1935
1936    *length = 0;
1937    _mesa_error(ctx, GL_INVALID_OPERATION,
1938                "glGetProgramBinary(driver supports zero binary formats)");
1939
1940    (void) binaryFormat;
1941    (void) binary;
1942 }
1943
1944 void GLAPIENTRY
1945 _mesa_ProgramBinary(GLuint program, GLenum binaryFormat,
1946                     const GLvoid *binary, GLsizei length)
1947 {
1948    struct gl_shader_program *shProg;
1949    GET_CURRENT_CONTEXT(ctx);
1950
1951    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramBinary");
1952    if (!shProg)
1953       return;
1954
1955    (void) binaryFormat;
1956    (void) binary;
1957
1958    /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
1959     *
1960     *     "If a negative number is provided where an argument of type sizei or
1961     *     sizeiptr is specified, an INVALID_VALUE error is generated."
1962     */
1963    if (length < 0) {
1964       _mesa_error(ctx, GL_INVALID_VALUE, "glProgramBinary(length < 0)");
1965       return;
1966    }
1967
1968    /* The ARB_get_program_binary spec says:
1969     *
1970     *     "<binaryFormat> and <binary> must be those returned by a previous
1971     *     call to GetProgramBinary, and <length> must be the length of the
1972     *     program binary as returned by GetProgramBinary or GetProgramiv with
1973     *     <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
1974     *     setting the LINK_STATUS of <program> to FALSE, if these conditions
1975     *     are not met."
1976     *
1977     * Since any value of binaryFormat passed "is not one of those specified as
1978     * allowable for [this] command, an INVALID_ENUM error is generated."
1979     */
1980    shProg->LinkStatus = GL_FALSE;
1981    _mesa_error(ctx, GL_INVALID_ENUM, "glProgramBinary");
1982 }
1983
1984
1985 void GLAPIENTRY
1986 _mesa_ProgramParameteri(GLuint program, GLenum pname, GLint value)
1987 {
1988    struct gl_shader_program *shProg;
1989    GET_CURRENT_CONTEXT(ctx);
1990
1991    shProg = _mesa_lookup_shader_program_err(ctx, program,
1992                                             "glProgramParameteri");
1993    if (!shProg)
1994       return;
1995
1996    switch (pname) {
1997    case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
1998       /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
1999        * is part of OpenGL ES 3.0.  For the ES2 case, this function shouldn't
2000        * even be in the dispatch table, so we shouldn't need to expclicitly
2001        * check here.
2002        *
2003        * On desktop, we ignore the 3.0+ requirement because it is silly.
2004        */
2005
2006       /* The ARB_get_program_binary extension spec says:
2007        *
2008        *     "An INVALID_VALUE error is generated if the <value> argument to
2009        *     ProgramParameteri is not TRUE or FALSE."
2010        */
2011       if (value != GL_TRUE && value != GL_FALSE) {
2012          goto invalid_value;
2013       }
2014
2015       /* No need to notify the driver.  Any changes will actually take effect
2016        * the next time the shader is linked.
2017        *
2018        * The ARB_get_program_binary extension spec says:
2019        *
2020        *     "To indicate that a program binary is likely to be retrieved,
2021        *     ProgramParameteri should be called with <pname>
2022        *     PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2023        *     will not be in effect until the next time LinkProgram or
2024        *     ProgramBinary has been called successfully."
2025        *
2026        * The resloution of issue 9 in the extension spec also says:
2027        *
2028        *     "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2029        *     to indicate to the GL implementation that this program will
2030        *     likely be saved with GetProgramBinary at some point. This will
2031        *     give the GL implementation the opportunity to track any state
2032        *     changes made to the program before being saved such that when it
2033        *     is loaded again a recompile can be avoided."
2034        */
2035       shProg->BinaryRetreivableHint = value;
2036       return;
2037
2038    case GL_PROGRAM_SEPARABLE:
2039       /* Spec imply that the behavior is the same as ARB_get_program_binary
2040        * Chapter 7.3 Program Objects
2041        */
2042       if (value != GL_TRUE && value != GL_FALSE) {
2043          goto invalid_value;
2044       }
2045       shProg->SeparateShader = value;
2046       return;
2047
2048    default:
2049       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteri(pname=%s)",
2050                   _mesa_enum_to_string(pname));
2051       return;
2052    }
2053
2054 invalid_value:
2055    _mesa_error(ctx, GL_INVALID_VALUE,
2056                "glProgramParameteri(pname=%s, value=%d): "
2057                "value must be 0 or 1.",
2058                _mesa_enum_to_string(pname),
2059                value);
2060 }
2061
2062
2063 void
2064 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
2065                          struct gl_shader_program *shProg,
2066                          struct gl_pipeline_object *shTarget)
2067 {
2068    gl_shader_stage stage = _mesa_shader_enum_to_shader_stage(type);
2069    use_shader_program(ctx, stage, shProg, shTarget);
2070
2071    if (ctx->Driver.UseProgram)
2072       ctx->Driver.UseProgram(ctx, shProg);
2073 }
2074
2075
2076 /**
2077  * Copy program-specific data generated by linking from the gl_shader_program
2078  * object to a specific gl_program object.
2079  */
2080 void
2081 _mesa_copy_linked_program_data(gl_shader_stage type,
2082                                const struct gl_shader_program *src,
2083                                struct gl_program *dst)
2084 {
2085    switch (type) {
2086    case MESA_SHADER_VERTEX:
2087       dst->ClipDistanceArraySize = src->Vert.ClipDistanceArraySize;
2088       break;
2089    case MESA_SHADER_TESS_CTRL: {
2090       struct gl_tess_ctrl_program *dst_tcp =
2091          (struct gl_tess_ctrl_program *) dst;
2092       dst_tcp->VerticesOut = src->TessCtrl.VerticesOut;
2093       break;
2094    }
2095    case MESA_SHADER_TESS_EVAL: {
2096       struct gl_tess_eval_program *dst_tep =
2097          (struct gl_tess_eval_program *) dst;
2098       dst_tep->PrimitiveMode = src->TessEval.PrimitiveMode;
2099       dst_tep->Spacing = src->TessEval.Spacing;
2100       dst_tep->VertexOrder = src->TessEval.VertexOrder;
2101       dst_tep->PointMode = src->TessEval.PointMode;
2102       dst->ClipDistanceArraySize = src->TessEval.ClipDistanceArraySize;
2103       break;
2104    }
2105    case MESA_SHADER_GEOMETRY: {
2106       struct gl_geometry_program *dst_gp = (struct gl_geometry_program *) dst;
2107       dst_gp->VerticesIn = src->Geom.VerticesIn;
2108       dst_gp->VerticesOut = src->Geom.VerticesOut;
2109       dst_gp->Invocations = src->Geom.Invocations;
2110       dst_gp->InputType = src->Geom.InputType;
2111       dst_gp->OutputType = src->Geom.OutputType;
2112       dst->ClipDistanceArraySize = src->Geom.ClipDistanceArraySize;
2113       dst_gp->UsesEndPrimitive = src->Geom.UsesEndPrimitive;
2114       dst_gp->UsesStreams = src->Geom.UsesStreams;
2115       break;
2116    }
2117    case MESA_SHADER_FRAGMENT: {
2118       struct gl_fragment_program *dst_fp = (struct gl_fragment_program *) dst;
2119       dst_fp->FragDepthLayout = src->FragDepthLayout;
2120       break;
2121    }
2122    case MESA_SHADER_COMPUTE: {
2123       struct gl_compute_program *dst_cp = (struct gl_compute_program *) dst;
2124       int i;
2125       for (i = 0; i < 3; i++)
2126          dst_cp->LocalSize[i] = src->Comp.LocalSize[i];
2127       break;
2128    }
2129    default:
2130       break;
2131    }
2132 }
2133
2134 /**
2135  * ARB_separate_shader_objects: Compile & Link Program
2136  */
2137 GLuint GLAPIENTRY
2138 _mesa_CreateShaderProgramv(GLenum type, GLsizei count,
2139                            const GLchar* const *strings)
2140 {
2141    GET_CURRENT_CONTEXT(ctx);
2142
2143    const GLuint shader = create_shader(ctx, type);
2144    GLuint program = 0;
2145
2146    /*
2147     * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2148     * GL_INVALID_VALUE should be generated if count < 0
2149     */
2150    if (count < 0) {
2151       _mesa_error(ctx, GL_INVALID_VALUE, "glCreateShaderProgram (count < 0)");
2152       return program;
2153    }
2154
2155    if (shader) {
2156       _mesa_ShaderSource(shader, count, strings, NULL);
2157
2158       compile_shader(ctx, shader);
2159
2160       program = create_shader_program(ctx);
2161       if (program) {
2162          struct gl_shader_program *shProg;
2163          struct gl_shader *sh;
2164          GLint compiled = GL_FALSE;
2165
2166          shProg = _mesa_lookup_shader_program(ctx, program);
2167          sh = _mesa_lookup_shader(ctx, shader);
2168
2169          shProg->SeparateShader = GL_TRUE;
2170
2171          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
2172          if (compiled) {
2173             attach_shader(ctx, program, shader);
2174             link_program(ctx, program);
2175             detach_shader(ctx, program, shader);
2176
2177 #if 0
2178             /* Possibly... */
2179             if (active-user-defined-varyings-in-linked-program) {
2180                append-error-to-info-log;
2181                shProg->LinkStatus = GL_FALSE;
2182             }
2183 #endif
2184          }
2185          if (sh->InfoLog)
2186             ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
2187       }
2188
2189       delete_shader(ctx, shader);
2190    }
2191
2192    return program;
2193 }
2194
2195
2196 /**
2197  * For GL_ARB_tessellation_shader
2198  */
2199 extern void GLAPIENTRY
2200 _mesa_PatchParameteri(GLenum pname, GLint value)
2201 {
2202    GET_CURRENT_CONTEXT(ctx);
2203
2204    if (!_mesa_has_tessellation(ctx)) {
2205       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameteri");
2206       return;
2207    }
2208
2209    if (pname != GL_PATCH_VERTICES) {
2210       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameteri");
2211       return;
2212    }
2213
2214    if (value <= 0 || value > ctx->Const.MaxPatchVertices) {
2215       _mesa_error(ctx, GL_INVALID_VALUE, "glPatchParameteri");
2216       return;
2217    }
2218
2219    ctx->TessCtrlProgram.patch_vertices = value;
2220 }
2221
2222
2223 extern void GLAPIENTRY
2224 _mesa_PatchParameterfv(GLenum pname, const GLfloat *values)
2225 {
2226    GET_CURRENT_CONTEXT(ctx);
2227
2228    if (!_mesa_has_tessellation(ctx)) {
2229       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameterfv");
2230       return;
2231    }
2232
2233    switch(pname) {
2234    case GL_PATCH_DEFAULT_OUTER_LEVEL:
2235       FLUSH_VERTICES(ctx, 0);
2236       memcpy(ctx->TessCtrlProgram.patch_default_outer_level, values,
2237              4 * sizeof(GLfloat));
2238       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2239       return;
2240    case GL_PATCH_DEFAULT_INNER_LEVEL:
2241       FLUSH_VERTICES(ctx, 0);
2242       memcpy(ctx->TessCtrlProgram.patch_default_inner_level, values,
2243              2 * sizeof(GLfloat));
2244       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2245       return;
2246    default:
2247       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameterfv");
2248       return;
2249    }
2250 }
2251
2252 /**
2253  * ARB_shader_subroutine
2254  */
2255 GLint GLAPIENTRY
2256 _mesa_GetSubroutineUniformLocation(GLuint program, GLenum shadertype,
2257                                    const GLchar *name)
2258 {
2259    GET_CURRENT_CONTEXT(ctx);
2260    const char *api_name = "glGetSubroutineUniformLocation";
2261    struct gl_shader_program *shProg;
2262    GLenum resource_type;
2263    gl_shader_stage stage;
2264
2265    if (!_mesa_has_shader_subroutine(ctx)) {
2266       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2267       return -1;
2268    }
2269
2270    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2271       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2272       return -1;
2273    }
2274
2275    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2276    if (!shProg)
2277       return -1;
2278
2279    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2280    if (!shProg->_LinkedShaders[stage]) {
2281       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2282       return -1;
2283    }
2284
2285    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2286    return _mesa_program_resource_location(shProg, resource_type, name);
2287 }
2288
2289 GLuint GLAPIENTRY
2290 _mesa_GetSubroutineIndex(GLuint program, GLenum shadertype,
2291                          const GLchar *name)
2292 {
2293    GET_CURRENT_CONTEXT(ctx);
2294    const char *api_name = "glGetSubroutineIndex";
2295    struct gl_shader_program *shProg;
2296    struct gl_program_resource *res;
2297    GLenum resource_type;
2298    gl_shader_stage stage;
2299
2300    if (!_mesa_has_shader_subroutine(ctx)) {
2301       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2302       return -1;
2303    }
2304
2305    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2306       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2307       return -1;
2308    }
2309
2310    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2311    if (!shProg)
2312       return -1;
2313
2314    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2315    if (!shProg->_LinkedShaders[stage]) {
2316       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2317       return -1;
2318    }
2319
2320    resource_type = _mesa_shader_stage_to_subroutine(stage);
2321    res = _mesa_program_resource_find_name(shProg, resource_type, name, NULL);
2322    if (!res) {
2323       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2324      return -1;
2325    }
2326
2327    return _mesa_program_resource_index(shProg, res);
2328 }
2329
2330
2331 GLvoid GLAPIENTRY
2332 _mesa_GetActiveSubroutineUniformiv(GLuint program, GLenum shadertype,
2333                                    GLuint index, GLenum pname, GLint *values)
2334 {
2335    GET_CURRENT_CONTEXT(ctx);
2336    const char *api_name = "glGetActiveSubroutineUniformiv";
2337    struct gl_shader_program *shProg;
2338    struct gl_shader *sh;
2339    gl_shader_stage stage;
2340    struct gl_program_resource *res;
2341    const struct gl_uniform_storage *uni;
2342    GLenum resource_type;
2343    int count, i, j;
2344
2345    if (!_mesa_has_shader_subroutine(ctx)) {
2346       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2347       return;
2348    }
2349
2350    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2351       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2352       return;
2353    }
2354
2355    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2356    if (!shProg)
2357       return;
2358
2359    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2360    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2361
2362    sh = shProg->_LinkedShaders[stage];
2363    if (!sh) {
2364       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2365       return;
2366    }
2367
2368    switch (pname) {
2369    case GL_NUM_COMPATIBLE_SUBROUTINES: {
2370       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2371       if (res) {
2372          uni = res->Data;
2373          values[0] = uni->num_compatible_subroutines;
2374       }
2375       break;
2376    }
2377    case GL_COMPATIBLE_SUBROUTINES: {
2378       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2379       if (res) {
2380          uni = res->Data;
2381          count = 0;
2382          for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2383             struct gl_subroutine_function *fn = &sh->SubroutineFunctions[i];
2384             for (j = 0; j < fn->num_compat_types; j++) {
2385                if (fn->types[j] == uni->type) {
2386                   values[count++] = i;
2387                   break;
2388                }
2389             }
2390          }
2391       }
2392       break;
2393    }
2394    case GL_UNIFORM_SIZE:
2395       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2396       if (res) {
2397          uni = res->Data;
2398          values[0] = uni->array_elements ? uni->array_elements : 1;
2399       }
2400       break;
2401    case GL_UNIFORM_NAME_LENGTH:
2402       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2403       if (res) {
2404          values[0] = strlen(_mesa_program_resource_name(res)) + 1
2405             + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);;
2406       }
2407       break;
2408    default:
2409       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2410       return;
2411    }
2412 }
2413
2414
2415 GLvoid GLAPIENTRY
2416 _mesa_GetActiveSubroutineUniformName(GLuint program, GLenum shadertype,
2417                                      GLuint index, GLsizei bufsize,
2418                                      GLsizei *length, GLchar *name)
2419 {
2420    GET_CURRENT_CONTEXT(ctx);
2421    const char *api_name = "glGetActiveSubroutineUniformName";
2422    struct gl_shader_program *shProg;
2423    GLenum resource_type;
2424    gl_shader_stage stage;
2425
2426    if (!_mesa_has_shader_subroutine(ctx)) {
2427       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2428       return;
2429    }
2430
2431    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2432       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2433       return;
2434    }
2435
2436    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2437    if (!shProg)
2438       return;
2439
2440    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2441    if (!shProg->_LinkedShaders[stage]) {
2442       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2443       return;
2444    }
2445
2446    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2447    /* get program resource name */
2448    _mesa_get_program_resource_name(shProg, resource_type,
2449                                    index, bufsize,
2450                                    length, name, api_name);
2451 }
2452
2453
2454 GLvoid GLAPIENTRY
2455 _mesa_GetActiveSubroutineName(GLuint program, GLenum shadertype,
2456                               GLuint index, GLsizei bufsize,
2457                               GLsizei *length, GLchar *name)
2458 {
2459    GET_CURRENT_CONTEXT(ctx);
2460    const char *api_name = "glGetActiveSubroutineName";
2461    struct gl_shader_program *shProg;
2462    GLenum resource_type;
2463    gl_shader_stage stage;
2464
2465    if (!_mesa_has_shader_subroutine(ctx)) {
2466       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2467       return;
2468    }
2469
2470    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2471       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2472       return;
2473    }
2474
2475    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2476    if (!shProg)
2477       return;
2478
2479    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2480    if (!shProg->_LinkedShaders[stage]) {
2481       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2482       return;
2483    }
2484    resource_type = _mesa_shader_stage_to_subroutine(stage);
2485    _mesa_get_program_resource_name(shProg, resource_type,
2486                                    index, bufsize,
2487                                    length, name, api_name);
2488 }
2489
2490
2491 GLvoid GLAPIENTRY
2492 _mesa_UniformSubroutinesuiv(GLenum shadertype, GLsizei count,
2493                             const GLuint *indices)
2494 {
2495    GET_CURRENT_CONTEXT(ctx);
2496    const char *api_name = "glUniformSubroutinesuiv";
2497    struct gl_shader_program *shProg;
2498    struct gl_shader *sh;
2499    gl_shader_stage stage;
2500    int i;
2501
2502    if (!_mesa_has_shader_subroutine(ctx)) {
2503       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2504       return;
2505    }
2506
2507    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2508       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2509       return;
2510    }
2511
2512    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2513    shProg = ctx->_Shader->CurrentProgram[stage];
2514    if (!shProg) {
2515       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2516       return;
2517    }
2518
2519    sh = shProg->_LinkedShaders[stage];
2520    if (!sh) {
2521       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2522       return;
2523    }
2524
2525    if (count != sh->NumSubroutineUniformRemapTable) {
2526       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2527       return;
2528    }
2529
2530    i = 0;
2531    do {
2532       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2533       int uni_count = uni->array_elements ? uni->array_elements : 1;
2534       int j, k;
2535
2536       for (j = i; j < i + uni_count; j++) {
2537          struct gl_subroutine_function *subfn;
2538          if (indices[j] >= sh->NumSubroutineFunctions) {
2539             _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2540             return;
2541          }
2542
2543          subfn = &sh->SubroutineFunctions[indices[j]];
2544          for (k = 0; k < subfn->num_compat_types; k++) {
2545             if (subfn->types[k] == uni->type)
2546                break;
2547          }
2548          if (k == subfn->num_compat_types) {
2549             _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2550             return;
2551          }
2552       }
2553       i += uni_count;
2554    } while(i < count);
2555
2556    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
2557    i = 0;
2558    do {
2559       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2560       int uni_count = uni->array_elements ? uni->array_elements : 1;
2561
2562       memcpy(&uni->storage[0], &indices[i],
2563              sizeof(GLuint) * uni_count);
2564
2565       uni->initialized = true;
2566       _mesa_propagate_uniforms_to_driver_storage(uni, 0, uni_count);
2567       i += uni_count;
2568    } while(i < count);
2569 }
2570
2571
2572 GLvoid GLAPIENTRY
2573 _mesa_GetUniformSubroutineuiv(GLenum shadertype, GLint location,
2574                               GLuint *params)
2575 {
2576    GET_CURRENT_CONTEXT(ctx);
2577    const char *api_name = "glGetUniformSubroutineuiv";
2578    struct gl_shader_program *shProg;
2579    struct gl_shader *sh;
2580    gl_shader_stage stage;
2581
2582    if (!_mesa_has_shader_subroutine(ctx)) {
2583       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2584       return;
2585    }
2586
2587    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2588       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2589       return;
2590    }
2591
2592    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2593    shProg = ctx->_Shader->CurrentProgram[stage];
2594    if (!shProg) {
2595       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2596       return;
2597    }
2598
2599    sh = shProg->_LinkedShaders[stage];
2600    if (!sh) {
2601       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2602       return;
2603    }
2604
2605    if (location >= sh->NumSubroutineUniformRemapTable) {
2606       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2607       return;
2608    }
2609
2610    {
2611       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[location];
2612       int offset = location - uni->opaque[stage].index;
2613       memcpy(params, &uni->storage[offset],
2614              sizeof(GLuint));
2615    }
2616 }
2617
2618
2619 GLvoid GLAPIENTRY
2620 _mesa_GetProgramStageiv(GLuint program, GLenum shadertype,
2621                         GLenum pname, GLint *values)
2622 {
2623    GET_CURRENT_CONTEXT(ctx);
2624    const char *api_name = "glGetProgramStageiv";
2625    struct gl_shader_program *shProg;
2626    struct gl_shader *sh;
2627    gl_shader_stage stage;
2628
2629    if (!_mesa_has_shader_subroutine(ctx)) {
2630       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2631       return;
2632    }
2633
2634    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2635       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2636       return;
2637    }
2638
2639    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2640    if (!shProg)
2641       return;
2642
2643    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2644    sh = shProg->_LinkedShaders[stage];
2645    if (!sh) {
2646       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2647       return;
2648    }
2649
2650    switch (pname) {
2651    case GL_ACTIVE_SUBROUTINES:
2652       values[0] = sh->NumSubroutineFunctions;
2653       break;
2654    case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS:
2655       values[0] = sh->NumSubroutineUniformRemapTable;
2656       break;
2657    case GL_ACTIVE_SUBROUTINE_UNIFORMS:
2658       values[0] = sh->NumSubroutineUniformTypes;
2659       break;
2660    case GL_ACTIVE_SUBROUTINE_MAX_LENGTH:
2661    {
2662       unsigned i;
2663       GLint max_len = 0;
2664       GLenum resource_type;
2665       struct gl_program_resource *res;
2666
2667       resource_type = _mesa_shader_stage_to_subroutine(stage);
2668       for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2669          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2670          if (res) {
2671             const GLint len = strlen(_mesa_program_resource_name(res)) + 1;
2672             if (len > max_len)
2673                max_len = len;
2674          }
2675       }
2676       values[0] = max_len;
2677       break;
2678    }
2679    case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH:
2680    {
2681       unsigned i;
2682       GLint max_len = 0;
2683       GLenum resource_type;
2684       struct gl_program_resource *res;
2685
2686       resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2687       for (i = 0; i < sh->NumSubroutineUniformRemapTable; i++) {
2688          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2689          if (res) {
2690             const GLint len = strlen(_mesa_program_resource_name(res)) + 1
2691                + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);
2692
2693             if (len > max_len)
2694                max_len = len;
2695          }
2696       }
2697       values[0] = max_len;
2698       break;
2699    }
2700    default:
2701       _mesa_error(ctx, GL_INVALID_ENUM, "%s", api_name);
2702       values[0] = -1;
2703       break;
2704    }
2705 }
2706
2707 static int
2708 find_compat_subroutine(struct gl_shader *sh, const struct glsl_type *type)
2709 {
2710    int i, j;
2711
2712    for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2713       struct gl_subroutine_function *fn = &sh->SubroutineFunctions[i];
2714       for (j = 0; j < fn->num_compat_types; j++) {
2715          if (fn->types[j] == type)
2716             return i;
2717       }
2718    }
2719    return 0;
2720 }
2721
2722 static void
2723 _mesa_shader_init_subroutine_defaults(struct gl_shader *sh)
2724 {
2725    int i, j;
2726
2727    for (i = 0; i < sh->NumSubroutineUniformRemapTable; i++) {
2728       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2729       int uni_count;
2730       int val;
2731
2732       if (!uni)
2733          continue;
2734       uni_count = uni->array_elements ? uni->array_elements : 1;
2735       val = find_compat_subroutine(sh, uni->type);
2736
2737       for (j = 0; j < uni_count; j++)
2738          memcpy(&uni->storage[j], &val, sizeof(int));
2739       uni->initialized = true;
2740       _mesa_propagate_uniforms_to_driver_storage(uni, 0, uni_count);
2741    }
2742 }
2743
2744 void
2745 _mesa_shader_program_init_subroutine_defaults(struct gl_shader_program *shProg)
2746 {
2747    int i;
2748
2749    if (!shProg)
2750       return;
2751
2752    for (i = 0; i < MESA_SHADER_STAGES; i++) {
2753       if (!shProg->_LinkedShaders[i])
2754          continue;
2755
2756       _mesa_shader_init_subroutine_defaults(shProg->_LinkedShaders[i]);
2757    }
2758 }