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