src/mesa/main/shaderapi.c

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