src/mesa/main/shaderapi.c

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