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 "compiler/glsl/glsl_parser_extras.h"
  53 #include "compiler/glsl/ir.h"
  54 #include "compiler/glsl/ir_uniform.h"
  55 #include "compiler/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, struct gl_shader *sh)
 964 {
 965    if (!sh)
 966       return;
 967
 968    if (!sh->Source) {
 969       /* If the user called glCompileShader without first calling
 970        * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
 971        */
 972       sh->CompileStatus = GL_FALSE;
 973    } else {
 974       if (ctx->_Shader->Flags & GLSL_DUMP) {
 975          _mesa_log("GLSL source for %s shader %d:\n",
 976                  _mesa_shader_stage_to_string(sh->Stage), sh->Name);
 977          _mesa_log("%s\n", sh->Source);
 978       }
 979
 980       /* this call will set the shader->CompileStatus field to indicate if
 981        * compilation was successful.
 982        */
 983       _mesa_glsl_compile_shader(ctx, sh, false, false);
 984
 985       if (ctx->_Shader->Flags & GLSL_LOG) {
 986          _mesa_write_shader_to_file(sh);
 987       }
 988
 989       if (ctx->_Shader->Flags & GLSL_DUMP) {
 990          if (sh->CompileStatus) {
 991             _mesa_log("GLSL IR for shader %d:\n", sh->Name);
 992             _mesa_print_ir(_mesa_get_log_file(), sh->ir, NULL);
 993             _mesa_log("\n\n");
 994          } else {
 995             _mesa_log("GLSL shader %d failed to compile.\n", sh->Name);
 996          }
 997          if (sh->InfoLog && sh->InfoLog[0] != 0) {
 998             _mesa_log("GLSL shader %d info log:\n", sh->Name);
 999             _mesa_log("%s\n", sh->InfoLog);
1000          }
1001       }
1002    }
1003
1004    if (!sh->CompileStatus) {
1005       if (ctx->_Shader->Flags & GLSL_DUMP_ON_ERROR) {
1006          _mesa_log("GLSL source for %s shader %d:\n",
1007                  _mesa_shader_stage_to_string(sh->Stage), sh->Name);
1008          _mesa_log("%s\n", sh->Source);
1009          _mesa_log("Info Log:\n%s\n", sh->InfoLog);
1010       }
1011
1012       if (ctx->_Shader->Flags & GLSL_REPORT_ERRORS) {
1013          _mesa_debug(ctx, "Error compiling shader %u:\n%s\n",
1014                      sh->Name, sh->InfoLog);
1015       }
1016    }
1017 }
1018
1019
1020 /**
1021  * Link a program's shaders.
1022  */
1023 static void
1024 link_program(struct gl_context *ctx, GLuint program)
1025 {
1026    struct gl_shader_program *shProg;
1027
1028    shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
1029    if (!shProg)
1030       return;
1031
1032    /* From the ARB_transform_feedback2 specification:
1033     * "The error INVALID_OPERATION is generated by LinkProgram if <program> is
1034     *  the name of a program being used by one or more transform feedback
1035     *  objects, even if the objects are not currently bound or are paused."
1036     */
1037    if (_mesa_transform_feedback_is_using_program(ctx, shProg)) {
1038       _mesa_error(ctx, GL_INVALID_OPERATION,
1039                   "glLinkProgram(transform feedback is using the program)");
1040       return;
1041    }
1042
1043    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
1044
1045    _mesa_glsl_link_shader(ctx, shProg);
1046
1047    if (shProg->LinkStatus == GL_FALSE &&
1048        (ctx->_Shader->Flags & GLSL_REPORT_ERRORS)) {
1049       _mesa_debug(ctx, "Error linking program %u:\n%s\n",
1050                   shProg->Name, shProg->InfoLog);
1051    }
1052
1053    /* debug code */
1054    if (0) {
1055       GLuint i;
1056
1057       printf("Link %u shaders in program %u: %s\n",
1058                    shProg->NumShaders, shProg->Name,
1059                    shProg->LinkStatus ? "Success" : "Failed");
1060
1061       for (i = 0; i < shProg->NumShaders; i++) {
1062          printf(" shader %u, type 0x%x\n",
1063                       shProg->Shaders[i]->Name,
1064                       shProg->Shaders[i]->Type);
1065       }
1066    }
1067 }
1068
1069
1070 /**
1071  * Print basic shader info (for debug).
1072  */
1073 static void
1074 print_shader_info(const struct gl_shader_program *shProg)
1075 {
1076    GLuint i;
1077
1078    printf("Mesa: glUseProgram(%u)\n", shProg->Name);
1079    for (i = 0; i < shProg->NumShaders; i++) {
1080       printf("  %s shader %u, checksum %u\n",
1081              _mesa_shader_stage_to_string(shProg->Shaders[i]->Stage),
1082              shProg->Shaders[i]->Name,
1083              shProg->Shaders[i]->SourceChecksum);
1084    }
1085    if (shProg->_LinkedShaders[MESA_SHADER_VERTEX])
1086       printf("  vert prog %u\n",
1087              shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program->Id);
1088    if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT])
1089       printf("  frag prog %u\n",
1090              shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program->Id);
1091    if (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY])
1092       printf("  geom prog %u\n",
1093              shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program->Id);
1094    if (shProg->_LinkedShaders[MESA_SHADER_TESS_CTRL])
1095       printf("  tesc prog %u\n",
1096              shProg->_LinkedShaders[MESA_SHADER_TESS_CTRL]->Program->Id);
1097    if (shProg->_LinkedShaders[MESA_SHADER_TESS_EVAL])
1098       printf("  tese prog %u\n",
1099              shProg->_LinkedShaders[MESA_SHADER_TESS_EVAL]->Program->Id);
1100 }
1101
1102
1103 /**
1104  * Use the named shader program for subsequent glUniform calls
1105  */
1106 void
1107 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
1108                      const char *caller)
1109 {
1110    if ((shProg != NULL) && !shProg->LinkStatus) {
1111       _mesa_error(ctx, GL_INVALID_OPERATION,
1112                   "%s(program %u not linked)", caller, shProg->Name);
1113       return;
1114    }
1115
1116    if (ctx->Shader.ActiveProgram != shProg) {
1117       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
1118    }
1119 }
1120
1121
1122 static void
1123 use_shader_program(struct gl_context *ctx, gl_shader_stage stage,
1124                    struct gl_shader_program *shProg,
1125                    struct gl_pipeline_object *shTarget)
1126 {
1127    struct gl_shader_program **target;
1128
1129    target = &shTarget->CurrentProgram[stage];
1130    if ((shProg != NULL) && (shProg->_LinkedShaders[stage] == NULL))
1131       shProg = NULL;
1132
1133    if (*target != shProg) {
1134       /* Program is current, flush it */
1135       if (shTarget == ctx->_Shader) {
1136          FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
1137       }
1138
1139       /* If the shader is also bound as the current rendering shader, unbind
1140        * it from that binding point as well.  This ensures that the correct
1141        * semantics of glDeleteProgram are maintained.
1142        */
1143       switch (stage) {
1144       case MESA_SHADER_VERTEX:
1145       case MESA_SHADER_TESS_CTRL:
1146       case MESA_SHADER_TESS_EVAL:
1147       case MESA_SHADER_GEOMETRY:
1148       case MESA_SHADER_COMPUTE:
1149          /* Empty for now. */
1150          break;
1151       case MESA_SHADER_FRAGMENT:
1152          if (*target == ctx->_Shader->_CurrentFragmentProgram) {
1153             _mesa_reference_shader_program(ctx,
1154                                            &ctx->_Shader->_CurrentFragmentProgram,
1155                                            NULL);
1156          }
1157          break;
1158       }
1159
1160       _mesa_reference_shader_program(ctx, target, shProg);
1161       return;
1162    }
1163 }
1164
1165
1166 /**
1167  * Use the named shader program for subsequent rendering.
1168  */
1169 void
1170 _mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
1171 {
1172    int i;
1173    for (i = 0; i < MESA_SHADER_STAGES; i++)
1174       use_shader_program(ctx, i, shProg, &ctx->Shader);
1175    _mesa_active_program(ctx, shProg, "glUseProgram");
1176
1177    _mesa_shader_program_init_subroutine_defaults(shProg);
1178    if (ctx->Driver.UseProgram)
1179       ctx->Driver.UseProgram(ctx, shProg);
1180 }
1181
1182
1183 /**
1184  * Do validation of the given shader program.
1185  * \param errMsg  returns error message if validation fails.
1186  * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1187  */
1188 static GLboolean
1189 validate_shader_program(const struct gl_shader_program *shProg,
1190                         char *errMsg)
1191 {
1192    if (!shProg->LinkStatus) {
1193       return GL_FALSE;
1194    }
1195
1196    /* From the GL spec, a program is invalid if any of these are true:
1197
1198      any two active samplers in the current program object are of
1199      different types, but refer to the same texture image unit,
1200
1201      any active sampler in the current program object refers to a texture
1202      image unit where fixed-function fragment processing accesses a
1203      texture target that does not match the sampler type, or
1204
1205      the sum of the number of active samplers in the program and the
1206      number of texture image units enabled for fixed-function fragment
1207      processing exceeds the combined limit on the total number of texture
1208      image units allowed.
1209    */
1210
1211    /*
1212     * Check: any two active samplers in the current program object are of
1213     * different types, but refer to the same texture image unit,
1214     */
1215    if (!_mesa_sampler_uniforms_are_valid(shProg, errMsg, 100))
1216       return GL_FALSE;
1217
1218    return GL_TRUE;
1219 }
1220
1221
1222 /**
1223  * Called via glValidateProgram()
1224  */
1225 static void
1226 validate_program(struct gl_context *ctx, GLuint program)
1227 {
1228    struct gl_shader_program *shProg;
1229    char errMsg[100] = "";
1230
1231    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1232    if (!shProg) {
1233       return;
1234    }
1235
1236    shProg->Validated = validate_shader_program(shProg, errMsg);
1237    if (!shProg->Validated) {
1238       /* update info log */
1239       if (shProg->InfoLog) {
1240          ralloc_free(shProg->InfoLog);
1241       }
1242       shProg->InfoLog = ralloc_strdup(shProg, errMsg);
1243    }
1244 }
1245
1246
1247
1248 void GLAPIENTRY
1249 _mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
1250 {
1251    GET_CURRENT_CONTEXT(ctx);
1252    attach_shader(ctx, program, shader);
1253 }
1254
1255
1256 void GLAPIENTRY
1257 _mesa_AttachShader(GLuint program, GLuint shader)
1258 {
1259    GET_CURRENT_CONTEXT(ctx);
1260    attach_shader(ctx, program, shader);
1261 }
1262
1263
1264 void GLAPIENTRY
1265 _mesa_CompileShader(GLuint shaderObj)
1266 {
1267    GET_CURRENT_CONTEXT(ctx);
1268    if (MESA_VERBOSE & VERBOSE_API)
1269       _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
1270    compile_shader(ctx,
1271                   _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader"));
1272 }
1273
1274
1275 GLuint GLAPIENTRY
1276 _mesa_CreateShader(GLenum type)
1277 {
1278    GET_CURRENT_CONTEXT(ctx);
1279    if (MESA_VERBOSE & VERBOSE_API)
1280       _mesa_debug(ctx, "glCreateShader %s\n", _mesa_enum_to_string(type));
1281    return create_shader(ctx, type);
1282 }
1283
1284
1285 GLhandleARB GLAPIENTRY
1286 _mesa_CreateShaderObjectARB(GLenum type)
1287 {
1288    GET_CURRENT_CONTEXT(ctx);
1289    return create_shader(ctx, type);
1290 }
1291
1292
1293 GLuint GLAPIENTRY
1294 _mesa_CreateProgram(void)
1295 {
1296    GET_CURRENT_CONTEXT(ctx);
1297    if (MESA_VERBOSE & VERBOSE_API)
1298       _mesa_debug(ctx, "glCreateProgram\n");
1299    return create_shader_program(ctx);
1300 }
1301
1302
1303 GLhandleARB GLAPIENTRY
1304 _mesa_CreateProgramObjectARB(void)
1305 {
1306    GET_CURRENT_CONTEXT(ctx);
1307    return create_shader_program(ctx);
1308 }
1309
1310
1311 void GLAPIENTRY
1312 _mesa_DeleteObjectARB(GLhandleARB obj)
1313 {
1314    if (MESA_VERBOSE & VERBOSE_API) {
1315       GET_CURRENT_CONTEXT(ctx);
1316       _mesa_debug(ctx, "glDeleteObjectARB(%lu)\n", (unsigned long)obj);
1317    }
1318
1319    if (obj) {
1320       GET_CURRENT_CONTEXT(ctx);
1321       FLUSH_VERTICES(ctx, 0);
1322       if (is_program(ctx, obj)) {
1323          delete_shader_program(ctx, obj);
1324       }
1325       else if (is_shader(ctx, obj)) {
1326          delete_shader(ctx, obj);
1327       }
1328       else {
1329          /* error? */
1330       }
1331    }
1332 }
1333
1334
1335 void GLAPIENTRY
1336 _mesa_DeleteProgram(GLuint name)
1337 {
1338    if (name) {
1339       GET_CURRENT_CONTEXT(ctx);
1340       FLUSH_VERTICES(ctx, 0);
1341       delete_shader_program(ctx, name);
1342    }
1343 }
1344
1345
1346 void GLAPIENTRY
1347 _mesa_DeleteShader(GLuint name)
1348 {
1349    if (name) {
1350       GET_CURRENT_CONTEXT(ctx);
1351       FLUSH_VERTICES(ctx, 0);
1352       delete_shader(ctx, name);
1353    }
1354 }
1355
1356
1357 void GLAPIENTRY
1358 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
1359 {
1360    GET_CURRENT_CONTEXT(ctx);
1361    detach_shader(ctx, program, shader);
1362 }
1363
1364
1365 void GLAPIENTRY
1366 _mesa_DetachShader(GLuint program, GLuint shader)
1367 {
1368    GET_CURRENT_CONTEXT(ctx);
1369    detach_shader(ctx, program, shader);
1370 }
1371
1372
1373 void GLAPIENTRY
1374 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
1375                             GLsizei * count, GLhandleARB * obj)
1376 {
1377    GET_CURRENT_CONTEXT(ctx);
1378    get_attached_shaders(ctx, container, maxCount, count, obj);
1379 }
1380
1381
1382 void GLAPIENTRY
1383 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
1384                          GLsizei *count, GLuint *obj)
1385 {
1386    GET_CURRENT_CONTEXT(ctx);
1387    get_attached_shaders(ctx, program, maxCount, count, obj);
1388 }
1389
1390
1391 void GLAPIENTRY
1392 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
1393                     GLcharARB * infoLog)
1394 {
1395    GET_CURRENT_CONTEXT(ctx);
1396    if (is_program(ctx, object)) {
1397       get_program_info_log(ctx, object, maxLength, length, infoLog);
1398    }
1399    else if (is_shader(ctx, object)) {
1400       get_shader_info_log(ctx, object, maxLength, length, infoLog);
1401    }
1402    else {
1403       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1404    }
1405 }
1406
1407
1408 void GLAPIENTRY
1409 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
1410 {
1411    GET_CURRENT_CONTEXT(ctx);
1412    /* Implement in terms of GetProgramiv, GetShaderiv */
1413    if (is_program(ctx, object)) {
1414       if (pname == GL_OBJECT_TYPE_ARB) {
1415          *params = GL_PROGRAM_OBJECT_ARB;
1416       }
1417       else {
1418          get_programiv(ctx, object, pname, params);
1419       }
1420    }
1421    else if (is_shader(ctx, object)) {
1422       if (pname == GL_OBJECT_TYPE_ARB) {
1423          *params = GL_SHADER_OBJECT_ARB;
1424       }
1425       else {
1426          get_shaderiv(ctx, object, pname, params);
1427       }
1428    }
1429    else {
1430       _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1431    }
1432 }
1433
1434
1435 void GLAPIENTRY
1436 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
1437                               GLfloat *params)
1438 {
1439    GLint iparams[1] = {0};  /* XXX is one element enough? */
1440    _mesa_GetObjectParameterivARB(object, pname, iparams);
1441    params[0] = (GLfloat) iparams[0];
1442 }
1443
1444
1445 void GLAPIENTRY
1446 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
1447 {
1448    GET_CURRENT_CONTEXT(ctx);
1449    get_programiv(ctx, program, pname, params);
1450 }
1451
1452
1453 void GLAPIENTRY
1454 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
1455 {
1456    GET_CURRENT_CONTEXT(ctx);
1457    get_shaderiv(ctx, shader, pname, params);
1458 }
1459
1460
1461 void GLAPIENTRY
1462 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
1463                         GLsizei *length, GLchar *infoLog)
1464 {
1465    GET_CURRENT_CONTEXT(ctx);
1466    get_program_info_log(ctx, program, bufSize, length, infoLog);
1467 }
1468
1469
1470 void GLAPIENTRY
1471 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
1472                        GLsizei *length, GLchar *infoLog)
1473 {
1474    GET_CURRENT_CONTEXT(ctx);
1475    get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1476 }
1477
1478
1479 void GLAPIENTRY
1480 _mesa_GetShaderSource(GLuint shader, GLsizei maxLength,
1481                       GLsizei *length, GLchar *sourceOut)
1482 {
1483    GET_CURRENT_CONTEXT(ctx);
1484    get_shader_source(ctx, shader, maxLength, length, sourceOut);
1485 }
1486
1487
1488 GLhandleARB GLAPIENTRY
1489 _mesa_GetHandleARB(GLenum pname)
1490 {
1491    GET_CURRENT_CONTEXT(ctx);
1492    return get_handle(ctx, pname);
1493 }
1494
1495
1496 GLboolean GLAPIENTRY
1497 _mesa_IsProgram(GLuint name)
1498 {
1499    GET_CURRENT_CONTEXT(ctx);
1500    return is_program(ctx, name);
1501 }
1502
1503
1504 GLboolean GLAPIENTRY
1505 _mesa_IsShader(GLuint name)
1506 {
1507    GET_CURRENT_CONTEXT(ctx);
1508    return is_shader(ctx, name);
1509 }
1510
1511
1512 void GLAPIENTRY
1513 _mesa_LinkProgram(GLuint programObj)
1514 {
1515    GET_CURRENT_CONTEXT(ctx);
1516    if (MESA_VERBOSE & VERBOSE_API)
1517       _mesa_debug(ctx, "glLinkProgram %u\n", programObj);
1518    link_program(ctx, programObj);
1519 }
1520
1521 #if defined(HAVE_SHA1)
1522 /**
1523  * Generate a SHA-1 hash value string for given source string.
1524  */
1525 static void
1526 generate_sha1(const char *source, char sha_str[64])
1527 {
1528    unsigned char sha[20];
1529    _mesa_sha1_compute(source, strlen(source), sha);
1530    _mesa_sha1_format(sha_str, sha);
1531 }
1532
1533 /**
1534  * Construct a full path for shader replacement functionality using
1535  * following format:
1536  *
1537  * <path>/<stage prefix>_<CHECKSUM>.glsl
1538  */
1539 static void
1540 construct_name(const gl_shader_stage stage, const char *source,
1541                const char *path, char *name, unsigned length)
1542 {
1543    char sha[64];
1544    static const char *types[] = {
1545       "VS", "TC", "TE", "GS", "FS", "CS",
1546    };
1547
1548    generate_sha1(source, sha);
1549    _mesa_snprintf(name, length, "%s/%s_%s.glsl", path, types[stage],
1550                   sha);
1551 }
1552
1553 /**
1554  * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1555  */
1556 static void
1557 dump_shader(const gl_shader_stage stage, const char *source)
1558 {
1559    char name[PATH_MAX];
1560    static bool path_exists = true;
1561    char *dump_path;
1562    FILE *f;
1563
1564    if (!path_exists)
1565       return;
1566
1567    dump_path = getenv("MESA_SHADER_DUMP_PATH");
1568    if (!dump_path) {
1569       path_exists = false;
1570       return;
1571    }
1572
1573    construct_name(stage, source, dump_path, name, PATH_MAX);
1574
1575    f = fopen(name, "w");
1576    if (f) {
1577       fputs(source, f);
1578       fclose(f);
1579    } else {
1580       GET_CURRENT_CONTEXT(ctx);
1581       _mesa_warning(ctx, "could not open %s for dumping shader (%s)", name,
1582                     strerror(errno));
1583    }
1584 }
1585
1586 /**
1587  * Read shader source code from a file.
1588  * Useful for debugging to override an app's shader.
1589  */
1590 static GLcharARB *
1591 read_shader(const gl_shader_stage stage, const char *source)
1592 {
1593    char name[PATH_MAX];
1594    char *read_path;
1595    static bool path_exists = true;
1596    int len, shader_size = 0;
1597    GLcharARB *buffer;
1598    FILE *f;
1599
1600    if (!path_exists)
1601       return NULL;
1602
1603    read_path = getenv("MESA_SHADER_READ_PATH");
1604    if (!read_path) {
1605       path_exists = false;
1606       return NULL;
1607    }
1608
1609    construct_name(stage, source, read_path, name, PATH_MAX);
1610
1611    f = fopen(name, "r");
1612    if (!f)
1613       return NULL;
1614
1615    /* allocate enough room for the entire shader */
1616    fseek(f, 0, SEEK_END);
1617    shader_size = ftell(f);
1618    rewind(f);
1619    assert(shader_size);
1620
1621    /* add one for terminating zero */
1622    shader_size++;
1623
1624    buffer = malloc(shader_size);
1625    assert(buffer);
1626
1627    len = fread(buffer, 1, shader_size, f);
1628    buffer[len] = 0;
1629
1630    fclose(f);
1631
1632    return buffer;
1633 }
1634 #endif /* HAVE_SHA1 */
1635
1636 /**
1637  * Called via glShaderSource() and glShaderSourceARB() API functions.
1638  * Basically, concatenate the source code strings into one long string
1639  * and pass it to _mesa_shader_source().
1640  */
1641 void GLAPIENTRY
1642 _mesa_ShaderSource(GLuint shaderObj, GLsizei count,
1643                    const GLchar * const * string, const GLint * length)
1644 {
1645    GET_CURRENT_CONTEXT(ctx);
1646    GLint *offsets;
1647    GLsizei i, totalLength;
1648    GLcharARB *source;
1649    struct gl_shader *sh;
1650
1651 #if defined(HAVE_SHA1)
1652    GLcharARB *replacement;
1653 #endif /* HAVE_SHA1 */
1654
1655    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glShaderSourceARB");
1656    if (!sh)
1657       return;
1658
1659    if (string == NULL) {
1660       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1661       return;
1662    }
1663
1664    /*
1665     * This array holds offsets of where the appropriate string ends, thus the
1666     * last element will be set to the total length of the source code.
1667     */
1668    offsets = malloc(count * sizeof(GLint));
1669    if (offsets == NULL) {
1670       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1671       return;
1672    }
1673
1674    for (i = 0; i < count; i++) {
1675       if (string[i] == NULL) {
1676          free((GLvoid *) offsets);
1677          _mesa_error(ctx, GL_INVALID_OPERATION,
1678                      "glShaderSourceARB(null string)");
1679          return;
1680       }
1681       if (length == NULL || length[i] < 0)
1682          offsets[i] = strlen(string[i]);
1683       else
1684          offsets[i] = length[i];
1685       /* accumulate string lengths */
1686       if (i > 0)
1687          offsets[i] += offsets[i - 1];
1688    }
1689
1690    /* Total length of source string is sum off all strings plus two.
1691     * One extra byte for terminating zero, another extra byte to silence
1692     * valgrind warnings in the parser/grammer code.
1693     */
1694    totalLength = offsets[count - 1] + 2;
1695    source = malloc(totalLength * sizeof(GLcharARB));
1696    if (source == NULL) {
1697       free((GLvoid *) offsets);
1698       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1699       return;
1700    }
1701
1702    for (i = 0; i < count; i++) {
1703       GLint start = (i > 0) ? offsets[i - 1] : 0;
1704       memcpy(source + start, string[i],
1705              (offsets[i] - start) * sizeof(GLcharARB));
1706    }
1707    source[totalLength - 1] = '\0';
1708    source[totalLength - 2] = '\0';
1709
1710 #if defined(HAVE_SHA1)
1711    /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
1712     * if corresponding entry found from MESA_SHADER_READ_PATH.
1713     */
1714    dump_shader(sh->Stage, source);
1715
1716    replacement = read_shader(sh->Stage, source);
1717    if (replacement) {
1718       free(source);
1719       source = replacement;
1720    }
1721 #endif /* HAVE_SHA1 */
1722
1723    shader_source(sh, source);
1724
1725    free(offsets);
1726 }
1727
1728
1729 void GLAPIENTRY
1730 _mesa_UseProgram(GLuint program)
1731 {
1732    GET_CURRENT_CONTEXT(ctx);
1733    struct gl_shader_program *shProg;
1734
1735    if (MESA_VERBOSE & VERBOSE_API)
1736       _mesa_debug(ctx, "glUseProgram %u\n", program);
1737
1738    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1739       _mesa_error(ctx, GL_INVALID_OPERATION,
1740                   "glUseProgram(transform feedback active)");
1741       return;
1742    }
1743
1744    if (program) {
1745       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1746       if (!shProg) {
1747          return;
1748       }
1749       if (!shProg->LinkStatus) {
1750          _mesa_error(ctx, GL_INVALID_OPERATION,
1751                      "glUseProgram(program %u not linked)", program);
1752          return;
1753       }
1754
1755       /* debug code */
1756       if (ctx->_Shader->Flags & GLSL_USE_PROG) {
1757          print_shader_info(shProg);
1758       }
1759    }
1760    else {
1761       shProg = NULL;
1762    }
1763
1764    /* The ARB_separate_shader_object spec says:
1765     *
1766     *     "The executable code for an individual shader stage is taken from
1767     *     the current program for that stage.  If there is a current program
1768     *     object established by UseProgram, that program is considered current
1769     *     for all stages.  Otherwise, if there is a bound program pipeline
1770     *     object (section 2.14.PPO), the program bound to the appropriate
1771     *     stage of the pipeline object is considered current."
1772     */
1773    if (program) {
1774       /* Attach shader state to the binding point */
1775       _mesa_reference_pipeline_object(ctx, &ctx->_Shader, &ctx->Shader);
1776       /* Update the program */
1777       _mesa_use_program(ctx, shProg);
1778    } else {
1779       /* Must be done first: detach the progam */
1780       _mesa_use_program(ctx, shProg);
1781       /* Unattach shader_state binding point */
1782       _mesa_reference_pipeline_object(ctx, &ctx->_Shader, ctx->Pipeline.Default);
1783       /* If a pipeline was bound, rebind it */
1784       if (ctx->Pipeline.Current) {
1785          _mesa_BindProgramPipeline(ctx->Pipeline.Current->Name);
1786       }
1787    }
1788 }
1789
1790
1791 void GLAPIENTRY
1792 _mesa_ValidateProgram(GLuint program)
1793 {
1794    GET_CURRENT_CONTEXT(ctx);
1795    validate_program(ctx, program);
1796 }
1797
1798
1799 /**
1800  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1801  */
1802 void GLAPIENTRY
1803 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1804                                GLint* range, GLint* precision)
1805 {
1806    const struct gl_program_constants *limits;
1807    const struct gl_precision *p;
1808    GET_CURRENT_CONTEXT(ctx);
1809
1810    switch (shadertype) {
1811    case GL_VERTEX_SHADER:
1812       limits = &ctx->Const.Program[MESA_SHADER_VERTEX];
1813       break;
1814    case GL_FRAGMENT_SHADER:
1815       limits = &ctx->Const.Program[MESA_SHADER_FRAGMENT];
1816       break;
1817    default:
1818       _mesa_error(ctx, GL_INVALID_ENUM,
1819                   "glGetShaderPrecisionFormat(shadertype)");
1820       return;
1821    }
1822
1823    switch (precisiontype) {
1824    case GL_LOW_FLOAT:
1825       p = &limits->LowFloat;
1826       break;
1827    case GL_MEDIUM_FLOAT:
1828       p = &limits->MediumFloat;
1829       break;
1830    case GL_HIGH_FLOAT:
1831       p = &limits->HighFloat;
1832       break;
1833    case GL_LOW_INT:
1834       p = &limits->LowInt;
1835       break;
1836    case GL_MEDIUM_INT:
1837       p = &limits->MediumInt;
1838       break;
1839    case GL_HIGH_INT:
1840       p = &limits->HighInt;
1841       break;
1842    default:
1843       _mesa_error(ctx, GL_INVALID_ENUM,
1844                   "glGetShaderPrecisionFormat(precisiontype)");
1845       return;
1846    }
1847
1848    range[0] = p->RangeMin;
1849    range[1] = p->RangeMax;
1850    precision[0] = p->Precision;
1851 }
1852
1853
1854 /**
1855  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1856  */
1857 void GLAPIENTRY
1858 _mesa_ReleaseShaderCompiler(void)
1859 {
1860    _mesa_destroy_shader_compiler_caches();
1861 }
1862
1863
1864 /**
1865  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1866  */
1867 void GLAPIENTRY
1868 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1869                    const void* binary, GLint length)
1870 {
1871    GET_CURRENT_CONTEXT(ctx);
1872    (void) shaders;
1873    (void) binaryformat;
1874    (void) binary;
1875
1876    /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
1877     * page 88 of the OpenGL 4.5 specs state:
1878     *
1879     *     "An INVALID_VALUE error is generated if count or length is negative.
1880     *      An INVALID_ENUM error is generated if binaryformat is not a supported
1881     *      format returned in SHADER_BINARY_FORMATS."
1882     */
1883    if (n < 0 || length < 0) {
1884       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderBinary(count or length < 0)");
1885       return;
1886    }
1887
1888    _mesa_error(ctx, GL_INVALID_ENUM, "glShaderBinary(format)");
1889 }
1890
1891
1892 void GLAPIENTRY
1893 _mesa_GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
1894                        GLenum *binaryFormat, GLvoid *binary)
1895 {
1896    struct gl_shader_program *shProg;
1897    GLsizei length_dummy;
1898    GET_CURRENT_CONTEXT(ctx);
1899
1900    if (bufSize < 0){
1901       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramBinary(bufSize < 0)");
1902       return;
1903    }
1904
1905    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetProgramBinary");
1906    if (!shProg)
1907       return;
1908
1909    /* The ARB_get_program_binary spec says:
1910     *
1911     *     "If <length> is NULL, then no length is returned."
1912     *
1913     * Ensure that length always points to valid storage to avoid multiple NULL
1914     * pointer checks below.
1915     */
1916    if (length == NULL)
1917       length = &length_dummy;
1918
1919
1920    /* The ARB_get_program_binary spec says:
1921     *
1922     *     "When a program object's LINK_STATUS is FALSE, its program binary
1923     *     length is zero, and a call to GetProgramBinary will generate an
1924     *     INVALID_OPERATION error.
1925     */
1926    if (!shProg->LinkStatus) {
1927       _mesa_error(ctx, GL_INVALID_OPERATION,
1928                   "glGetProgramBinary(program %u not linked)",
1929                   shProg->Name);
1930       *length = 0;
1931       return;
1932    }
1933
1934    *length = 0;
1935    _mesa_error(ctx, GL_INVALID_OPERATION,
1936                "glGetProgramBinary(driver supports zero binary formats)");
1937
1938    (void) binaryFormat;
1939    (void) binary;
1940 }
1941
1942 void GLAPIENTRY
1943 _mesa_ProgramBinary(GLuint program, GLenum binaryFormat,
1944                     const GLvoid *binary, GLsizei length)
1945 {
1946    struct gl_shader_program *shProg;
1947    GET_CURRENT_CONTEXT(ctx);
1948
1949    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramBinary");
1950    if (!shProg)
1951       return;
1952
1953    (void) binaryFormat;
1954    (void) binary;
1955
1956    /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
1957     *
1958     *     "If a negative number is provided where an argument of type sizei or
1959     *     sizeiptr is specified, an INVALID_VALUE error is generated."
1960     */
1961    if (length < 0) {
1962       _mesa_error(ctx, GL_INVALID_VALUE, "glProgramBinary(length < 0)");
1963       return;
1964    }
1965
1966    /* The ARB_get_program_binary spec says:
1967     *
1968     *     "<binaryFormat> and <binary> must be those returned by a previous
1969     *     call to GetProgramBinary, and <length> must be the length of the
1970     *     program binary as returned by GetProgramBinary or GetProgramiv with
1971     *     <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
1972     *     setting the LINK_STATUS of <program> to FALSE, if these conditions
1973     *     are not met."
1974     *
1975     * Since any value of binaryFormat passed "is not one of those specified as
1976     * allowable for [this] command, an INVALID_ENUM error is generated."
1977     */
1978    shProg->LinkStatus = GL_FALSE;
1979    _mesa_error(ctx, GL_INVALID_ENUM, "glProgramBinary");
1980 }
1981
1982
1983 void GLAPIENTRY
1984 _mesa_ProgramParameteri(GLuint program, GLenum pname, GLint value)
1985 {
1986    struct gl_shader_program *shProg;
1987    GET_CURRENT_CONTEXT(ctx);
1988
1989    shProg = _mesa_lookup_shader_program_err(ctx, program,
1990                                             "glProgramParameteri");
1991    if (!shProg)
1992       return;
1993
1994    switch (pname) {
1995    case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
1996       /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
1997        * is part of OpenGL ES 3.0.  For the ES2 case, this function shouldn't
1998        * even be in the dispatch table, so we shouldn't need to expclicitly
1999        * check here.
2000        *
2001        * On desktop, we ignore the 3.0+ requirement because it is silly.
2002        */
2003
2004       /* The ARB_get_program_binary extension spec says:
2005        *
2006        *     "An INVALID_VALUE error is generated if the <value> argument to
2007        *     ProgramParameteri is not TRUE or FALSE."
2008        */
2009       if (value != GL_TRUE && value != GL_FALSE) {
2010          goto invalid_value;
2011       }
2012
2013       /* No need to notify the driver.  Any changes will actually take effect
2014        * the next time the shader is linked.
2015        *
2016        * The ARB_get_program_binary extension spec says:
2017        *
2018        *     "To indicate that a program binary is likely to be retrieved,
2019        *     ProgramParameteri should be called with <pname>
2020        *     PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2021        *     will not be in effect until the next time LinkProgram or
2022        *     ProgramBinary has been called successfully."
2023        *
2024        * The resloution of issue 9 in the extension spec also says:
2025        *
2026        *     "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2027        *     to indicate to the GL implementation that this program will
2028        *     likely be saved with GetProgramBinary at some point. This will
2029        *     give the GL implementation the opportunity to track any state
2030        *     changes made to the program before being saved such that when it
2031        *     is loaded again a recompile can be avoided."
2032        */
2033       shProg->BinaryRetreivableHint = value;
2034       return;
2035
2036    case GL_PROGRAM_SEPARABLE:
2037       /* Spec imply that the behavior is the same as ARB_get_program_binary
2038        * Chapter 7.3 Program Objects
2039        */
2040       if (value != GL_TRUE && value != GL_FALSE) {
2041          goto invalid_value;
2042       }
2043       shProg->SeparateShader = value;
2044       return;
2045
2046    default:
2047       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteri(pname=%s)",
2048                   _mesa_enum_to_string(pname));
2049       return;
2050    }
2051
2052 invalid_value:
2053    _mesa_error(ctx, GL_INVALID_VALUE,
2054                "glProgramParameteri(pname=%s, value=%d): "
2055                "value must be 0 or 1.",
2056                _mesa_enum_to_string(pname),
2057                value);
2058 }
2059
2060
2061 void
2062 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
2063                          struct gl_shader_program *shProg,
2064                          struct gl_pipeline_object *shTarget)
2065 {
2066    gl_shader_stage stage = _mesa_shader_enum_to_shader_stage(type);
2067    use_shader_program(ctx, stage, shProg, shTarget);
2068
2069    if (ctx->Driver.UseProgram)
2070       ctx->Driver.UseProgram(ctx, shProg);
2071 }
2072
2073
2074 /**
2075  * Copy program-specific data generated by linking from the gl_shader_program
2076  * object to a specific gl_program object.
2077  */
2078 void
2079 _mesa_copy_linked_program_data(gl_shader_stage type,
2080                                const struct gl_shader_program *src,
2081                                struct gl_program *dst)
2082 {
2083    switch (type) {
2084    case MESA_SHADER_VERTEX:
2085       dst->ClipDistanceArraySize = src->Vert.ClipDistanceArraySize;
2086       break;
2087    case MESA_SHADER_TESS_CTRL: {
2088       struct gl_tess_ctrl_program *dst_tcp =
2089          (struct gl_tess_ctrl_program *) dst;
2090       dst_tcp->VerticesOut = src->TessCtrl.VerticesOut;
2091       break;
2092    }
2093    case MESA_SHADER_TESS_EVAL: {
2094       struct gl_tess_eval_program *dst_tep =
2095          (struct gl_tess_eval_program *) dst;
2096       dst_tep->PrimitiveMode = src->TessEval.PrimitiveMode;
2097       dst_tep->Spacing = src->TessEval.Spacing;
2098       dst_tep->VertexOrder = src->TessEval.VertexOrder;
2099       dst_tep->PointMode = src->TessEval.PointMode;
2100       dst->ClipDistanceArraySize = src->TessEval.ClipDistanceArraySize;
2101       break;
2102    }
2103    case MESA_SHADER_GEOMETRY: {
2104       struct gl_geometry_program *dst_gp = (struct gl_geometry_program *) dst;
2105       dst_gp->VerticesIn = src->Geom.VerticesIn;
2106       dst_gp->VerticesOut = src->Geom.VerticesOut;
2107       dst_gp->Invocations = src->Geom.Invocations;
2108       dst_gp->InputType = src->Geom.InputType;
2109       dst_gp->OutputType = src->Geom.OutputType;
2110       dst->ClipDistanceArraySize = src->Geom.ClipDistanceArraySize;
2111       dst_gp->UsesEndPrimitive = src->Geom.UsesEndPrimitive;
2112       dst_gp->UsesStreams = src->Geom.UsesStreams;
2113       break;
2114    }
2115    case MESA_SHADER_FRAGMENT: {
2116       struct gl_fragment_program *dst_fp = (struct gl_fragment_program *) dst;
2117       dst_fp->FragDepthLayout = src->FragDepthLayout;
2118       break;
2119    }
2120    case MESA_SHADER_COMPUTE: {
2121       struct gl_compute_program *dst_cp = (struct gl_compute_program *) dst;
2122       int i;
2123       for (i = 0; i < 3; i++)
2124          dst_cp->LocalSize[i] = src->Comp.LocalSize[i];
2125       dst_cp->SharedSize = src->Comp.SharedSize;
2126       break;
2127    }
2128    default:
2129       break;
2130    }
2131 }
2132
2133 /**
2134  * ARB_separate_shader_objects: Compile & Link Program
2135  */
2136 GLuint GLAPIENTRY
2137 _mesa_CreateShaderProgramv(GLenum type, GLsizei count,
2138                            const GLchar* const *strings)
2139 {
2140    GET_CURRENT_CONTEXT(ctx);
2141
2142    const GLuint shader = create_shader(ctx, type);
2143    GLuint program = 0;
2144
2145    /*
2146     * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2147     * GL_INVALID_VALUE should be generated if count < 0
2148     */
2149    if (count < 0) {
2150       _mesa_error(ctx, GL_INVALID_VALUE, "glCreateShaderProgram (count < 0)");
2151       return program;
2152    }
2153
2154    if (shader) {
2155       struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
2156
2157       _mesa_ShaderSource(shader, count, strings, NULL);
2158       compile_shader(ctx, sh);
2159
2160       program = create_shader_program(ctx);
2161       if (program) {
2162          struct gl_shader_program *shProg;
2163          GLint compiled = GL_FALSE;
2164
2165          shProg = _mesa_lookup_shader_program(ctx, program);
2166
2167          shProg->SeparateShader = GL_TRUE;
2168
2169          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
2170          if (compiled) {
2171             attach_shader(ctx, program, shader);
2172             link_program(ctx, program);
2173             detach_shader(ctx, program, shader);
2174
2175 #if 0
2176             /* Possibly... */
2177             if (active-user-defined-varyings-in-linked-program) {
2178                append-error-to-info-log;
2179                shProg->LinkStatus = GL_FALSE;
2180             }
2181 #endif
2182          }
2183          if (sh->InfoLog)
2184             ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
2185       }
2186
2187       delete_shader(ctx, shader);
2188    }
2189
2190    return program;
2191 }
2192
2193
2194 /**
2195  * For GL_ARB_tessellation_shader
2196  */
2197 extern void GLAPIENTRY
2198 _mesa_PatchParameteri(GLenum pname, GLint value)
2199 {
2200    GET_CURRENT_CONTEXT(ctx);
2201
2202    if (!_mesa_has_tessellation(ctx)) {
2203       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameteri");
2204       return;
2205    }
2206
2207    if (pname != GL_PATCH_VERTICES) {
2208       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameteri");
2209       return;
2210    }
2211
2212    if (value <= 0 || value > ctx->Const.MaxPatchVertices) {
2213       _mesa_error(ctx, GL_INVALID_VALUE, "glPatchParameteri");
2214       return;
2215    }
2216
2217    ctx->TessCtrlProgram.patch_vertices = value;
2218 }
2219
2220
2221 extern void GLAPIENTRY
2222 _mesa_PatchParameterfv(GLenum pname, const GLfloat *values)
2223 {
2224    GET_CURRENT_CONTEXT(ctx);
2225
2226    if (!_mesa_has_tessellation(ctx)) {
2227       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameterfv");
2228       return;
2229    }
2230
2231    switch(pname) {
2232    case GL_PATCH_DEFAULT_OUTER_LEVEL:
2233       FLUSH_VERTICES(ctx, 0);
2234       memcpy(ctx->TessCtrlProgram.patch_default_outer_level, values,
2235              4 * sizeof(GLfloat));
2236       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2237       return;
2238    case GL_PATCH_DEFAULT_INNER_LEVEL:
2239       FLUSH_VERTICES(ctx, 0);
2240       memcpy(ctx->TessCtrlProgram.patch_default_inner_level, values,
2241              2 * sizeof(GLfloat));
2242       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2243       return;
2244    default:
2245       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameterfv");
2246       return;
2247    }
2248 }
2249
2250 /**
2251  * ARB_shader_subroutine
2252  */
2253 GLint GLAPIENTRY
2254 _mesa_GetSubroutineUniformLocation(GLuint program, GLenum shadertype,
2255                                    const GLchar *name)
2256 {
2257    GET_CURRENT_CONTEXT(ctx);
2258    const char *api_name = "glGetSubroutineUniformLocation";
2259    struct gl_shader_program *shProg;
2260    GLenum resource_type;
2261    gl_shader_stage stage;
2262
2263    if (!_mesa_has_shader_subroutine(ctx)) {
2264       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2265       return -1;
2266    }
2267
2268    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2269       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2270       return -1;
2271    }
2272
2273    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2274    if (!shProg)
2275       return -1;
2276
2277    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2278    if (!shProg->_LinkedShaders[stage]) {
2279       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2280       return -1;
2281    }
2282
2283    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2284    return _mesa_program_resource_location(shProg, resource_type, name);
2285 }
2286
2287 GLuint GLAPIENTRY
2288 _mesa_GetSubroutineIndex(GLuint program, GLenum shadertype,
2289                          const GLchar *name)
2290 {
2291    GET_CURRENT_CONTEXT(ctx);
2292    const char *api_name = "glGetSubroutineIndex";
2293    struct gl_shader_program *shProg;
2294    struct gl_program_resource *res;
2295    GLenum resource_type;
2296    gl_shader_stage stage;
2297
2298    if (!_mesa_has_shader_subroutine(ctx)) {
2299       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2300       return -1;
2301    }
2302
2303    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2304       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2305       return -1;
2306    }
2307
2308    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2309    if (!shProg)
2310       return -1;
2311
2312    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2313    if (!shProg->_LinkedShaders[stage]) {
2314       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2315       return -1;
2316    }
2317
2318    resource_type = _mesa_shader_stage_to_subroutine(stage);
2319    res = _mesa_program_resource_find_name(shProg, resource_type, name, NULL);
2320    if (!res) {
2321       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2322      return -1;
2323    }
2324
2325    return _mesa_program_resource_index(shProg, res);
2326 }
2327
2328
2329 GLvoid GLAPIENTRY
2330 _mesa_GetActiveSubroutineUniformiv(GLuint program, GLenum shadertype,
2331                                    GLuint index, GLenum pname, GLint *values)
2332 {
2333    GET_CURRENT_CONTEXT(ctx);
2334    const char *api_name = "glGetActiveSubroutineUniformiv";
2335    struct gl_shader_program *shProg;
2336    struct gl_shader *sh;
2337    gl_shader_stage stage;
2338    struct gl_program_resource *res;
2339    const struct gl_uniform_storage *uni;
2340    GLenum resource_type;
2341    int count, i, j;
2342
2343    if (!_mesa_has_shader_subroutine(ctx)) {
2344       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2345       return;
2346    }
2347
2348    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2349       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2350       return;
2351    }
2352
2353    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2354    if (!shProg)
2355       return;
2356
2357    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2358    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2359
2360    sh = shProg->_LinkedShaders[stage];
2361    if (!sh) {
2362       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2363       return;
2364    }
2365
2366    switch (pname) {
2367    case GL_NUM_COMPATIBLE_SUBROUTINES: {
2368       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2369       if (res) {
2370          uni = res->Data;
2371          values[0] = uni->num_compatible_subroutines;
2372       }
2373       break;
2374    }
2375    case GL_COMPATIBLE_SUBROUTINES: {
2376       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2377       if (res) {
2378          uni = res->Data;
2379          count = 0;
2380          for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2381             struct gl_subroutine_function *fn = &sh->SubroutineFunctions[i];
2382             for (j = 0; j < fn->num_compat_types; j++) {
2383                if (fn->types[j] == uni->type) {
2384                   values[count++] = i;
2385                   break;
2386                }
2387             }
2388          }
2389       }
2390       break;
2391    }
2392    case GL_UNIFORM_SIZE:
2393       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2394       if (res) {
2395          uni = res->Data;
2396          values[0] = uni->array_elements ? uni->array_elements : 1;
2397       }
2398       break;
2399    case GL_UNIFORM_NAME_LENGTH:
2400       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2401       if (res) {
2402          values[0] = strlen(_mesa_program_resource_name(res)) + 1
2403             + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);;
2404       }
2405       break;
2406    default:
2407       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2408       return;
2409    }
2410 }
2411
2412
2413 GLvoid GLAPIENTRY
2414 _mesa_GetActiveSubroutineUniformName(GLuint program, GLenum shadertype,
2415                                      GLuint index, GLsizei bufsize,
2416                                      GLsizei *length, GLchar *name)
2417 {
2418    GET_CURRENT_CONTEXT(ctx);
2419    const char *api_name = "glGetActiveSubroutineUniformName";
2420    struct gl_shader_program *shProg;
2421    GLenum resource_type;
2422    gl_shader_stage stage;
2423
2424    if (!_mesa_has_shader_subroutine(ctx)) {
2425       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2426       return;
2427    }
2428
2429    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2430       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2431       return;
2432    }
2433
2434    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2435    if (!shProg)
2436       return;
2437
2438    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2439    if (!shProg->_LinkedShaders[stage]) {
2440       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2441       return;
2442    }
2443
2444    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2445    /* get program resource name */
2446    _mesa_get_program_resource_name(shProg, resource_type,
2447                                    index, bufsize,
2448                                    length, name, api_name);
2449 }
2450
2451
2452 GLvoid GLAPIENTRY
2453 _mesa_GetActiveSubroutineName(GLuint program, GLenum shadertype,
2454                               GLuint index, GLsizei bufsize,
2455                               GLsizei *length, GLchar *name)
2456 {
2457    GET_CURRENT_CONTEXT(ctx);
2458    const char *api_name = "glGetActiveSubroutineName";
2459    struct gl_shader_program *shProg;
2460    GLenum resource_type;
2461    gl_shader_stage stage;
2462
2463    if (!_mesa_has_shader_subroutine(ctx)) {
2464       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2465       return;
2466    }
2467
2468    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2469       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2470       return;
2471    }
2472
2473    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2474    if (!shProg)
2475       return;
2476
2477    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2478    if (!shProg->_LinkedShaders[stage]) {
2479       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2480       return;
2481    }
2482    resource_type = _mesa_shader_stage_to_subroutine(stage);
2483    _mesa_get_program_resource_name(shProg, resource_type,
2484                                    index, bufsize,
2485                                    length, name, api_name);
2486 }
2487
2488
2489 GLvoid GLAPIENTRY
2490 _mesa_UniformSubroutinesuiv(GLenum shadertype, GLsizei count,
2491                             const GLuint *indices)
2492 {
2493    GET_CURRENT_CONTEXT(ctx);
2494    const char *api_name = "glUniformSubroutinesuiv";
2495    struct gl_shader_program *shProg;
2496    struct gl_shader *sh;
2497    gl_shader_stage stage;
2498    int i;
2499
2500    if (!_mesa_has_shader_subroutine(ctx)) {
2501       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2502       return;
2503    }
2504
2505    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2506       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2507       return;
2508    }
2509
2510    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2511    shProg = ctx->_Shader->CurrentProgram[stage];
2512    if (!shProg) {
2513       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2514       return;
2515    }
2516
2517    sh = shProg->_LinkedShaders[stage];
2518    if (!sh) {
2519       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2520       return;
2521    }
2522
2523    if (count != sh->NumSubroutineUniformRemapTable) {
2524       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2525       return;
2526    }
2527
2528    i = 0;
2529    do {
2530       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2531       if (uni == NULL) {
2532          i++;
2533          continue;
2534       }
2535
2536       int uni_count = uni->array_elements ? uni->array_elements : 1;
2537       int j, k;
2538
2539       for (j = i; j < i + uni_count; j++) {
2540          struct gl_subroutine_function *subfn;
2541          if (indices[j] >= sh->NumSubroutineFunctions) {
2542             _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2543             return;
2544          }
2545
2546          subfn = &sh->SubroutineFunctions[indices[j]];
2547          for (k = 0; k < subfn->num_compat_types; k++) {
2548             if (subfn->types[k] == uni->type)
2549                break;
2550          }
2551          if (k == subfn->num_compat_types) {
2552             _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2553             return;
2554          }
2555       }
2556       i += uni_count;
2557    } while(i < count);
2558
2559    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
2560    i = 0;
2561    do {
2562       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2563       if (uni == NULL) {
2564          i++;
2565          continue;
2566       }
2567
2568       int uni_count = uni->array_elements ? uni->array_elements : 1;
2569
2570       memcpy(&uni->storage[0], &indices[i],
2571              sizeof(GLuint) * uni_count);
2572
2573       uni->initialized = true;
2574       _mesa_propagate_uniforms_to_driver_storage(uni, 0, uni_count);
2575       i += uni_count;
2576    } while(i < count);
2577 }
2578
2579
2580 GLvoid GLAPIENTRY
2581 _mesa_GetUniformSubroutineuiv(GLenum shadertype, GLint location,
2582                               GLuint *params)
2583 {
2584    GET_CURRENT_CONTEXT(ctx);
2585    const char *api_name = "glGetUniformSubroutineuiv";
2586    struct gl_shader_program *shProg;
2587    struct gl_shader *sh;
2588    gl_shader_stage stage;
2589
2590    if (!_mesa_has_shader_subroutine(ctx)) {
2591       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2592       return;
2593    }
2594
2595    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2596       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2597       return;
2598    }
2599
2600    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2601    shProg = ctx->_Shader->CurrentProgram[stage];
2602    if (!shProg) {
2603       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2604       return;
2605    }
2606
2607    sh = shProg->_LinkedShaders[stage];
2608    if (!sh) {
2609       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2610       return;
2611    }
2612
2613    if (location >= sh->NumSubroutineUniformRemapTable) {
2614       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2615       return;
2616    }
2617
2618    {
2619       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[location];
2620       int offset = location - uni->opaque[stage].index;
2621       memcpy(params, &uni->storage[offset],
2622              sizeof(GLuint));
2623    }
2624 }
2625
2626
2627 GLvoid GLAPIENTRY
2628 _mesa_GetProgramStageiv(GLuint program, GLenum shadertype,
2629                         GLenum pname, GLint *values)
2630 {
2631    GET_CURRENT_CONTEXT(ctx);
2632    const char *api_name = "glGetProgramStageiv";
2633    struct gl_shader_program *shProg;
2634    struct gl_shader *sh;
2635    gl_shader_stage stage;
2636
2637    if (!_mesa_has_shader_subroutine(ctx)) {
2638       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2639       return;
2640    }
2641
2642    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2643       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2644       return;
2645    }
2646
2647    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2648    if (!shProg)
2649       return;
2650
2651    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2652    sh = shProg->_LinkedShaders[stage];
2653    if (!sh) {
2654       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2655       return;
2656    }
2657
2658    switch (pname) {
2659    case GL_ACTIVE_SUBROUTINES:
2660       values[0] = sh->NumSubroutineFunctions;
2661       break;
2662    case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS:
2663       values[0] = sh->NumSubroutineUniformRemapTable;
2664       break;
2665    case GL_ACTIVE_SUBROUTINE_UNIFORMS:
2666       values[0] = sh->NumSubroutineUniformTypes;
2667       break;
2668    case GL_ACTIVE_SUBROUTINE_MAX_LENGTH:
2669    {
2670       unsigned i;
2671       GLint max_len = 0;
2672       GLenum resource_type;
2673       struct gl_program_resource *res;
2674
2675       resource_type = _mesa_shader_stage_to_subroutine(stage);
2676       for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2677          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2678          if (res) {
2679             const GLint len = strlen(_mesa_program_resource_name(res)) + 1;
2680             if (len > max_len)
2681                max_len = len;
2682          }
2683       }
2684       values[0] = max_len;
2685       break;
2686    }
2687    case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH:
2688    {
2689       unsigned i;
2690       GLint max_len = 0;
2691       GLenum resource_type;
2692       struct gl_program_resource *res;
2693
2694       resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2695       for (i = 0; i < sh->NumSubroutineUniformRemapTable; i++) {
2696          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2697          if (res) {
2698             const GLint len = strlen(_mesa_program_resource_name(res)) + 1
2699                + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);
2700
2701             if (len > max_len)
2702                max_len = len;
2703          }
2704       }
2705       values[0] = max_len;
2706       break;
2707    }
2708    default:
2709       _mesa_error(ctx, GL_INVALID_ENUM, "%s", api_name);
2710       values[0] = -1;
2711       break;
2712    }
2713 }
2714
2715 static int
2716 find_compat_subroutine(struct gl_shader *sh, const struct glsl_type *type)
2717 {
2718    int i, j;
2719
2720    for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2721       struct gl_subroutine_function *fn = &sh->SubroutineFunctions[i];
2722       for (j = 0; j < fn->num_compat_types; j++) {
2723          if (fn->types[j] == type)
2724             return i;
2725       }
2726    }
2727    return 0;
2728 }
2729
2730 static void
2731 _mesa_shader_init_subroutine_defaults(struct gl_shader *sh)
2732 {
2733    int i, j;
2734
2735    for (i = 0; i < sh->NumSubroutineUniformRemapTable; i++) {
2736       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2737       int uni_count;
2738       int val;
2739
2740       if (!uni)
2741          continue;
2742       uni_count = uni->array_elements ? uni->array_elements : 1;
2743       val = find_compat_subroutine(sh, uni->type);
2744
2745       for (j = 0; j < uni_count; j++)
2746          memcpy(&uni->storage[j], &val, sizeof(int));
2747       uni->initialized = true;
2748       _mesa_propagate_uniforms_to_driver_storage(uni, 0, uni_count);
2749    }
2750 }
2751
2752 void
2753 _mesa_shader_program_init_subroutine_defaults(struct gl_shader_program *shProg)
2754 {
2755    int i;
2756
2757    if (!shProg)
2758       return;
2759
2760    for (i = 0; i < MESA_SHADER_STAGES; i++) {
2761       if (!shProg->_LinkedShaders[i])
2762          continue;
2763
2764       _mesa_shader_init_subroutine_defaults(shProg->_LinkedShaders[i]);
2765    }
2766 }