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_VERTEX:
2206       dst->ClipDistanceArraySize = src->Vert.ClipDistanceArraySize;
2207       dst->CullDistanceArraySize = src->Vert.CullDistanceArraySize;
2208       break;
2209    case MESA_SHADER_TESS_EVAL: {
2210       dst->info.tess.primitive_mode = dst_sh->info.TessEval.PrimitiveMode;
2211       dst->info.tess.spacing = dst_sh->info.TessEval.Spacing;
2212       dst->info.tess.ccw = dst_sh->info.TessEval.VertexOrder == GL_CCW;
2213       dst->info.tess.point_mode = dst_sh->info.TessEval.PointMode;
2214       dst->ClipDistanceArraySize = src->TessEval.ClipDistanceArraySize;
2215       dst->CullDistanceArraySize = src->TessEval.CullDistanceArraySize;
2216       break;
2217    }
2218    case MESA_SHADER_GEOMETRY: {
2219       dst->info.gs.vertices_in = src->Geom.VerticesIn;
2220       dst->info.gs.vertices_out = dst_sh->info.Geom.VerticesOut;
2221       dst->info.gs.invocations = dst_sh->info.Geom.Invocations;
2222       dst->info.gs.input_primitive = dst_sh->info.Geom.InputType;
2223       dst->info.gs.output_primitive = dst_sh->info.Geom.OutputType;
2224       dst->ClipDistanceArraySize = src->Geom.ClipDistanceArraySize;
2225       dst->CullDistanceArraySize = src->Geom.CullDistanceArraySize;
2226       dst->info.gs.uses_end_primitive = src->Geom.UsesEndPrimitive;
2227       dst->info.gs.uses_streams = src->Geom.UsesStreams;
2228       break;
2229    }
2230    case MESA_SHADER_FRAGMENT: {
2231       dst->info.fs.depth_layout = src->FragDepthLayout;
2232       break;
2233    }
2234    case MESA_SHADER_COMPUTE: {
2235       for (int i = 0; i < 3; i++)
2236          dst->info.cs.local_size[i] = src->Comp.LocalSize[i];
2237       dst->info.cs.shared_size = src->Comp.SharedSize;
2238       dst->info.cs.local_size_variable = src->Comp.LocalSizeVariable;
2239       break;
2240    }
2241    default:
2242       break;
2243    }
2244 }
2245
2246 /**
2247  * ARB_separate_shader_objects: Compile & Link Program
2248  */
2249 GLuint GLAPIENTRY
2250 _mesa_CreateShaderProgramv(GLenum type, GLsizei count,
2251                            const GLchar* const *strings)
2252 {
2253    GET_CURRENT_CONTEXT(ctx);
2254
2255    const GLuint shader = create_shader(ctx, type);
2256    GLuint program = 0;
2257
2258    /*
2259     * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2260     * GL_INVALID_VALUE should be generated if count < 0
2261     */
2262    if (count < 0) {
2263       _mesa_error(ctx, GL_INVALID_VALUE, "glCreateShaderProgram (count < 0)");
2264       return program;
2265    }
2266
2267    if (shader) {
2268       struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
2269
2270       _mesa_ShaderSource(shader, count, strings, NULL);
2271       _mesa_compile_shader(ctx, sh);
2272
2273       program = create_shader_program(ctx);
2274       if (program) {
2275          struct gl_shader_program *shProg;
2276          GLint compiled = GL_FALSE;
2277
2278          shProg = _mesa_lookup_shader_program(ctx, program);
2279
2280          shProg->SeparateShader = GL_TRUE;
2281
2282          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
2283          if (compiled) {
2284             attach_shader(ctx, program, shader);
2285             _mesa_link_program(ctx, shProg);
2286             detach_shader(ctx, program, shader);
2287
2288 #if 0
2289             /* Possibly... */
2290             if (active-user-defined-varyings-in-linked-program) {
2291                append-error-to-info-log;
2292                shProg->data->LinkStatus = GL_FALSE;
2293             }
2294 #endif
2295          }
2296          if (sh->InfoLog)
2297             ralloc_strcat(&shProg->data->InfoLog, sh->InfoLog);
2298       }
2299
2300       delete_shader(ctx, shader);
2301    }
2302
2303    return program;
2304 }
2305
2306
2307 /**
2308  * For GL_ARB_tessellation_shader
2309  */
2310 extern void GLAPIENTRY
2311 _mesa_PatchParameteri(GLenum pname, GLint value)
2312 {
2313    GET_CURRENT_CONTEXT(ctx);
2314
2315    if (!_mesa_has_tessellation(ctx)) {
2316       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameteri");
2317       return;
2318    }
2319
2320    if (pname != GL_PATCH_VERTICES) {
2321       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameteri");
2322       return;
2323    }
2324
2325    if (value <= 0 || value > ctx->Const.MaxPatchVertices) {
2326       _mesa_error(ctx, GL_INVALID_VALUE, "glPatchParameteri");
2327       return;
2328    }
2329
2330    ctx->TessCtrlProgram.patch_vertices = value;
2331 }
2332
2333
2334 extern void GLAPIENTRY
2335 _mesa_PatchParameterfv(GLenum pname, const GLfloat *values)
2336 {
2337    GET_CURRENT_CONTEXT(ctx);
2338
2339    if (!_mesa_has_tessellation(ctx)) {
2340       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameterfv");
2341       return;
2342    }
2343
2344    switch(pname) {
2345    case GL_PATCH_DEFAULT_OUTER_LEVEL:
2346       FLUSH_VERTICES(ctx, 0);
2347       memcpy(ctx->TessCtrlProgram.patch_default_outer_level, values,
2348              4 * sizeof(GLfloat));
2349       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2350       return;
2351    case GL_PATCH_DEFAULT_INNER_LEVEL:
2352       FLUSH_VERTICES(ctx, 0);
2353       memcpy(ctx->TessCtrlProgram.patch_default_inner_level, values,
2354              2 * sizeof(GLfloat));
2355       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2356       return;
2357    default:
2358       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameterfv");
2359       return;
2360    }
2361 }
2362
2363 /**
2364  * ARB_shader_subroutine
2365  */
2366 GLint GLAPIENTRY
2367 _mesa_GetSubroutineUniformLocation(GLuint program, GLenum shadertype,
2368                                    const GLchar *name)
2369 {
2370    GET_CURRENT_CONTEXT(ctx);
2371    const char *api_name = "glGetSubroutineUniformLocation";
2372    struct gl_shader_program *shProg;
2373    GLenum resource_type;
2374    gl_shader_stage stage;
2375
2376    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2377       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2378       return -1;
2379    }
2380
2381    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2382       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2383       return -1;
2384    }
2385
2386    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2387    if (!shProg)
2388       return -1;
2389
2390    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2391    if (!shProg->_LinkedShaders[stage]) {
2392       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2393       return -1;
2394    }
2395
2396    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2397    return _mesa_program_resource_location(shProg, resource_type, name);
2398 }
2399
2400 GLuint GLAPIENTRY
2401 _mesa_GetSubroutineIndex(GLuint program, GLenum shadertype,
2402                          const GLchar *name)
2403 {
2404    GET_CURRENT_CONTEXT(ctx);
2405    const char *api_name = "glGetSubroutineIndex";
2406    struct gl_shader_program *shProg;
2407    struct gl_program_resource *res;
2408    GLenum resource_type;
2409    gl_shader_stage stage;
2410
2411    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2412       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2413       return -1;
2414    }
2415
2416    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2417       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2418       return -1;
2419    }
2420
2421    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2422    if (!shProg)
2423       return -1;
2424
2425    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2426    if (!shProg->_LinkedShaders[stage]) {
2427       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2428       return -1;
2429    }
2430
2431    resource_type = _mesa_shader_stage_to_subroutine(stage);
2432    res = _mesa_program_resource_find_name(shProg, resource_type, name, NULL);
2433    if (!res) {
2434      return -1;
2435    }
2436
2437    return _mesa_program_resource_index(shProg, res);
2438 }
2439
2440
2441 GLvoid GLAPIENTRY
2442 _mesa_GetActiveSubroutineUniformiv(GLuint program, GLenum shadertype,
2443                                    GLuint index, GLenum pname, GLint *values)
2444 {
2445    GET_CURRENT_CONTEXT(ctx);
2446    const char *api_name = "glGetActiveSubroutineUniformiv";
2447    struct gl_shader_program *shProg;
2448    struct gl_linked_shader *sh;
2449    gl_shader_stage stage;
2450    struct gl_program_resource *res;
2451    const struct gl_uniform_storage *uni;
2452    GLenum resource_type;
2453    int count, i, j;
2454
2455    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2456       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2457       return;
2458    }
2459
2460    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2461       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2462       return;
2463    }
2464
2465    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2466    if (!shProg)
2467       return;
2468
2469    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2470    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2471
2472    sh = shProg->_LinkedShaders[stage];
2473    if (!sh) {
2474       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2475       return;
2476    }
2477
2478    struct gl_program *p = shProg->_LinkedShaders[stage]->Program;
2479    if (index >= p->sh.NumSubroutineUniforms) {
2480       _mesa_error(ctx, GL_INVALID_VALUE, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name);
2481       return;
2482    }
2483
2484    switch (pname) {
2485    case GL_NUM_COMPATIBLE_SUBROUTINES: {
2486       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2487       if (res) {
2488          uni = res->Data;
2489          values[0] = uni->num_compatible_subroutines;
2490       }
2491       break;
2492    }
2493    case GL_COMPATIBLE_SUBROUTINES: {
2494       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2495       if (res) {
2496          uni = res->Data;
2497          count = 0;
2498          for (i = 0; i < p->sh.NumSubroutineFunctions; i++) {
2499             struct gl_subroutine_function *fn = &p->sh.SubroutineFunctions[i];
2500             for (j = 0; j < fn->num_compat_types; j++) {
2501                if (fn->types[j] == uni->type) {
2502                   values[count++] = i;
2503                   break;
2504                }
2505             }
2506          }
2507       }
2508       break;
2509    }
2510    case GL_UNIFORM_SIZE:
2511       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2512       if (res) {
2513          uni = res->Data;
2514          values[0] = uni->array_elements ? uni->array_elements : 1;
2515       }
2516       break;
2517    case GL_UNIFORM_NAME_LENGTH:
2518       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2519       if (res) {
2520          values[0] = strlen(_mesa_program_resource_name(res)) + 1
2521             + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);
2522       }
2523       break;
2524    default:
2525       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2526       return;
2527    }
2528 }
2529
2530
2531 GLvoid GLAPIENTRY
2532 _mesa_GetActiveSubroutineUniformName(GLuint program, GLenum shadertype,
2533                                      GLuint index, GLsizei bufsize,
2534                                      GLsizei *length, GLchar *name)
2535 {
2536    GET_CURRENT_CONTEXT(ctx);
2537    const char *api_name = "glGetActiveSubroutineUniformName";
2538    struct gl_shader_program *shProg;
2539    GLenum resource_type;
2540    gl_shader_stage stage;
2541
2542    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2543       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2544       return;
2545    }
2546
2547    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2548       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2549       return;
2550    }
2551
2552    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2553    if (!shProg)
2554       return;
2555
2556    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2557    if (!shProg->_LinkedShaders[stage]) {
2558       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2559       return;
2560    }
2561
2562    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2563    /* get program resource name */
2564    _mesa_get_program_resource_name(shProg, resource_type,
2565                                    index, bufsize,
2566                                    length, name, api_name);
2567 }
2568
2569
2570 GLvoid GLAPIENTRY
2571 _mesa_GetActiveSubroutineName(GLuint program, GLenum shadertype,
2572                               GLuint index, GLsizei bufsize,
2573                               GLsizei *length, GLchar *name)
2574 {
2575    GET_CURRENT_CONTEXT(ctx);
2576    const char *api_name = "glGetActiveSubroutineName";
2577    struct gl_shader_program *shProg;
2578    GLenum resource_type;
2579    gl_shader_stage stage;
2580
2581    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2582       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2583       return;
2584    }
2585
2586    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2587       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2588       return;
2589    }
2590
2591    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2592    if (!shProg)
2593       return;
2594
2595    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2596    if (!shProg->_LinkedShaders[stage]) {
2597       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2598       return;
2599    }
2600    resource_type = _mesa_shader_stage_to_subroutine(stage);
2601    _mesa_get_program_resource_name(shProg, resource_type,
2602                                    index, bufsize,
2603                                    length, name, api_name);
2604 }
2605
2606 GLvoid GLAPIENTRY
2607 _mesa_UniformSubroutinesuiv(GLenum shadertype, GLsizei count,
2608                             const GLuint *indices)
2609 {
2610    GET_CURRENT_CONTEXT(ctx);
2611    const char *api_name = "glUniformSubroutinesuiv";
2612    gl_shader_stage stage;
2613    int i;
2614
2615    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2616       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2617       return;
2618    }
2619
2620    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2621       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2622       return;
2623    }
2624
2625    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2626    struct gl_program *p = ctx->_Shader->CurrentProgram[stage];
2627    if (!p) {
2628       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2629       return;
2630    }
2631
2632    if (count != p->sh.NumSubroutineUniformRemapTable) {
2633       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2634       return;
2635    }
2636
2637    i = 0;
2638    do {
2639       struct gl_uniform_storage *uni = p->sh.SubroutineUniformRemapTable[i];
2640       if (uni == NULL) {
2641          i++;
2642          continue;
2643       }
2644
2645       int uni_count = uni->array_elements ? uni->array_elements : 1;
2646       int j, k, f;
2647
2648       for (j = i; j < i + uni_count; j++) {
2649          struct gl_subroutine_function *subfn = NULL;
2650          if (indices[j] > p->sh.MaxSubroutineFunctionIndex) {
2651             _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2652             return;
2653          }
2654
2655          for (f = 0; f < p->sh.NumSubroutineFunctions; f++) {
2656             if (p->sh.SubroutineFunctions[f].index == indices[j])
2657                subfn = &p->sh.SubroutineFunctions[f];
2658          }
2659
2660          if (!subfn) {
2661             continue;
2662          }
2663
2664          for (k = 0; k < subfn->num_compat_types; k++) {
2665             if (subfn->types[k] == uni->type)
2666                break;
2667          }
2668          if (k == subfn->num_compat_types) {
2669             _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2670             return;
2671          }
2672
2673          ctx->SubroutineIndex[p->info.stage].IndexPtr[j] = indices[j];
2674       }
2675       i += uni_count;
2676    } while(i < count);
2677
2678    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
2679 }
2680
2681
2682 GLvoid GLAPIENTRY
2683 _mesa_GetUniformSubroutineuiv(GLenum shadertype, GLint location,
2684                               GLuint *params)
2685 {
2686    GET_CURRENT_CONTEXT(ctx);
2687    const char *api_name = "glGetUniformSubroutineuiv";
2688    gl_shader_stage stage;
2689
2690    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2691       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2692       return;
2693    }
2694
2695    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2696       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2697       return;
2698    }
2699
2700    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2701    struct gl_program *p = ctx->_Shader->CurrentProgram[stage];
2702    if (!p) {
2703       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2704       return;
2705    }
2706
2707    if (location >= p->sh.NumSubroutineUniformRemapTable) {
2708       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2709       return;
2710    }
2711
2712    *params = ctx->SubroutineIndex[p->info.stage].IndexPtr[location];
2713 }
2714
2715
2716 GLvoid GLAPIENTRY
2717 _mesa_GetProgramStageiv(GLuint program, GLenum shadertype,
2718                         GLenum pname, GLint *values)
2719 {
2720    GET_CURRENT_CONTEXT(ctx);
2721    const char *api_name = "glGetProgramStageiv";
2722    struct gl_shader_program *shProg;
2723    struct gl_linked_shader *sh;
2724    gl_shader_stage stage;
2725
2726    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2727       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2728       return;
2729    }
2730
2731    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2732       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2733       return;
2734    }
2735
2736    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2737    if (!shProg)
2738       return;
2739
2740    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2741    sh = shProg->_LinkedShaders[stage];
2742
2743    /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
2744     * INVALID_OPERATION in the case of not be linked.
2745     *
2746     * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
2747     * same info using other specs (ARB_program_interface_query), without the
2748     * need of the program to be linked, being the value for that case 0.
2749     *
2750     * But at the same time, some other methods require the program to be
2751     * linked for pname related to locations, so it would be inconsistent to
2752     * not do the same here. So we are:
2753     *   * Return GL_INVALID_OPERATION if not linked only for locations.
2754     *   * Setting a default value of 0, to be returned if not linked.
2755     */
2756    if (!sh) {
2757       values[0] = 0;
2758       if (pname == GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS) {
2759          _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2760       }
2761       return;
2762    }
2763
2764    struct gl_program *p = sh->Program;
2765    switch (pname) {
2766    case GL_ACTIVE_SUBROUTINES:
2767       values[0] = p->sh.NumSubroutineFunctions;
2768       break;
2769    case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS:
2770       values[0] = p->sh.NumSubroutineUniformRemapTable;
2771       break;
2772    case GL_ACTIVE_SUBROUTINE_UNIFORMS:
2773       values[0] = p->sh.NumSubroutineUniforms;
2774       break;
2775    case GL_ACTIVE_SUBROUTINE_MAX_LENGTH:
2776    {
2777       unsigned i;
2778       GLint max_len = 0;
2779       GLenum resource_type;
2780       struct gl_program_resource *res;
2781
2782       resource_type = _mesa_shader_stage_to_subroutine(stage);
2783       for (i = 0; i < p->sh.NumSubroutineFunctions; i++) {
2784          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2785          if (res) {
2786             const GLint len = strlen(_mesa_program_resource_name(res)) + 1;
2787             if (len > max_len)
2788                max_len = len;
2789          }
2790       }
2791       values[0] = max_len;
2792       break;
2793    }
2794    case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH:
2795    {
2796       unsigned i;
2797       GLint max_len = 0;
2798       GLenum resource_type;
2799       struct gl_program_resource *res;
2800
2801       resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2802       for (i = 0; i < p->sh.NumSubroutineUniformRemapTable; i++) {
2803          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2804          if (res) {
2805             const GLint len = strlen(_mesa_program_resource_name(res)) + 1
2806                + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);
2807
2808             if (len > max_len)
2809                max_len = len;
2810          }
2811       }
2812       values[0] = max_len;
2813       break;
2814    }
2815    default:
2816       _mesa_error(ctx, GL_INVALID_ENUM, "%s", api_name);
2817       values[0] = -1;
2818       break;
2819    }
2820 }
2821
2822 static int
2823 find_compat_subroutine(struct gl_program *p, const struct glsl_type *type)
2824 {
2825    int i, j;
2826
2827    for (i = 0; i < p->sh.NumSubroutineFunctions; i++) {
2828       struct gl_subroutine_function *fn = &p->sh.SubroutineFunctions[i];
2829       for (j = 0; j < fn->num_compat_types; j++) {
2830          if (fn->types[j] == type)
2831             return i;
2832       }
2833    }
2834    return 0;
2835 }
2836
2837 static void
2838 _mesa_shader_write_subroutine_index(struct gl_context *ctx,
2839                                     struct gl_program *p)
2840 {
2841    int i, j;
2842
2843    if (p->sh.NumSubroutineUniformRemapTable == 0)
2844       return;
2845
2846    i = 0;
2847    do {
2848       struct gl_uniform_storage *uni = p->sh.SubroutineUniformRemapTable[i];
2849       int uni_count;
2850       int val;
2851
2852       if (!uni) {
2853          i++;
2854          continue;
2855       }
2856
2857       uni_count = uni->array_elements ? uni->array_elements : 1;
2858       for (j = 0; j < uni_count; j++) {
2859          val = ctx->SubroutineIndex[p->info.stage].IndexPtr[i + j];
2860          memcpy(&uni->storage[j], &val, sizeof(int));
2861       }
2862
2863       _mesa_propagate_uniforms_to_driver_storage(uni, 0, uni_count);
2864       i += uni_count;
2865    } while(i < p->sh.NumSubroutineUniformRemapTable);
2866 }
2867
2868 void
2869 _mesa_shader_write_subroutine_indices(struct gl_context *ctx,
2870                                       gl_shader_stage stage)
2871 {
2872    if (ctx->_Shader->CurrentProgram[stage])
2873       _mesa_shader_write_subroutine_index(ctx,
2874                                           ctx->_Shader->CurrentProgram[stage]);
2875 }
2876
2877 void
2878 _mesa_program_init_subroutine_defaults(struct gl_context *ctx,
2879                                        struct gl_program *p)
2880 {
2881    assert(p);
2882
2883    struct gl_subroutine_index_binding *binding = &ctx->SubroutineIndex[p->info.stage];
2884    if (binding->NumIndex != p->sh.NumSubroutineUniformRemapTable) {
2885       binding->IndexPtr = realloc(binding->IndexPtr,
2886                                   p->sh.NumSubroutineUniformRemapTable * (sizeof(GLuint)));
2887       binding->NumIndex = p->sh.NumSubroutineUniformRemapTable;
2888    }
2889
2890    for (int i = 0; i < p->sh.NumSubroutineUniformRemapTable; i++) {
2891       struct gl_uniform_storage *uni = p->sh.SubroutineUniformRemapTable[i];
2892
2893       if (!uni)
2894          continue;
2895
2896       binding->IndexPtr[i] = find_compat_subroutine(p, uni->type);
2897    }
2898 }