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