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    link_program(ctx, programObj);
1518 }
1519
1520 #if defined(HAVE_SHA1)
1521 /**
1522  * Generate a SHA-1 hash value string for given source string.
1523  */
1524 static void
1525 generate_sha1(const char *source, char sha_str[64])
1526 {
1527    unsigned char sha[20];
1528    _mesa_sha1_compute(source, strlen(source), sha);
1529    _mesa_sha1_format(sha_str, sha);
1530 }
1531
1532 /**
1533  * Construct a full path for shader replacement functionality using
1534  * following format:
1535  *
1536  * <path>/<stage prefix>_<CHECKSUM>.glsl
1537  */
1538 static void
1539 construct_name(const gl_shader_stage stage, const char *source,
1540                const char *path, char *name, unsigned length)
1541 {
1542    char sha[64];
1543    static const char *types[] = {
1544       "VS", "TC", "TE", "GS", "FS", "CS",
1545    };
1546
1547    generate_sha1(source, sha);
1548    _mesa_snprintf(name, length, "%s/%s_%s.glsl", path, types[stage],
1549                   sha);
1550 }
1551
1552 /**
1553  * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1554  */
1555 static void
1556 dump_shader(const gl_shader_stage stage, const char *source)
1557 {
1558    char name[PATH_MAX];
1559    static bool path_exists = true;
1560    char *dump_path;
1561    FILE *f;
1562
1563    if (!path_exists)
1564       return;
1565
1566    dump_path = getenv("MESA_SHADER_DUMP_PATH");
1567    if (!dump_path) {
1568       path_exists = false;
1569       return;
1570    }
1571
1572    construct_name(stage, source, dump_path, name, PATH_MAX);
1573
1574    f = fopen(name, "w");
1575    if (f) {
1576       fputs(source, f);
1577       fclose(f);
1578    } else {
1579       GET_CURRENT_CONTEXT(ctx);
1580       _mesa_warning(ctx, "could not open %s for dumping shader (%s)", name,
1581                     strerror(errno));
1582    }
1583 }
1584
1585 /**
1586  * Read shader source code from a file.
1587  * Useful for debugging to override an app's shader.
1588  */
1589 static GLcharARB *
1590 read_shader(const gl_shader_stage stage, const char *source)
1591 {
1592    char name[PATH_MAX];
1593    char *read_path;
1594    static bool path_exists = true;
1595    int len, shader_size = 0;
1596    GLcharARB *buffer;
1597    FILE *f;
1598
1599    if (!path_exists)
1600       return NULL;
1601
1602    read_path = getenv("MESA_SHADER_READ_PATH");
1603    if (!read_path) {
1604       path_exists = false;
1605       return NULL;
1606    }
1607
1608    construct_name(stage, source, read_path, name, PATH_MAX);
1609
1610    f = fopen(name, "r");
1611    if (!f)
1612       return NULL;
1613
1614    /* allocate enough room for the entire shader */
1615    fseek(f, 0, SEEK_END);
1616    shader_size = ftell(f);
1617    rewind(f);
1618    assert(shader_size);
1619
1620    /* add one for terminating zero */
1621    shader_size++;
1622
1623    buffer = malloc(shader_size);
1624    assert(buffer);
1625
1626    len = fread(buffer, 1, shader_size, f);
1627    buffer[len] = 0;
1628
1629    fclose(f);
1630
1631    return buffer;
1632 }
1633 #endif /* HAVE_SHA1 */
1634
1635 /**
1636  * Called via glShaderSource() and glShaderSourceARB() API functions.
1637  * Basically, concatenate the source code strings into one long string
1638  * and pass it to _mesa_shader_source().
1639  */
1640 void GLAPIENTRY
1641 _mesa_ShaderSource(GLhandleARB shaderObj, GLsizei count,
1642                    const GLcharARB * const * string, const GLint * length)
1643 {
1644    GET_CURRENT_CONTEXT(ctx);
1645    GLint *offsets;
1646    GLsizei i, totalLength;
1647    GLcharARB *source;
1648    struct gl_shader *sh;
1649
1650 #if defined(HAVE_SHA1)
1651    GLcharARB *replacement;
1652 #endif /* HAVE_SHA1 */
1653
1654    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glShaderSourceARB");
1655    if (!sh)
1656       return;
1657
1658    if (string == NULL) {
1659       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1660       return;
1661    }
1662
1663    /*
1664     * This array holds offsets of where the appropriate string ends, thus the
1665     * last element will be set to the total length of the source code.
1666     */
1667    offsets = malloc(count * sizeof(GLint));
1668    if (offsets == NULL) {
1669       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1670       return;
1671    }
1672
1673    for (i = 0; i < count; i++) {
1674       if (string[i] == NULL) {
1675          free((GLvoid *) offsets);
1676          _mesa_error(ctx, GL_INVALID_OPERATION,
1677                      "glShaderSourceARB(null string)");
1678          return;
1679       }
1680       if (length == NULL || length[i] < 0)
1681          offsets[i] = strlen(string[i]);
1682       else
1683          offsets[i] = length[i];
1684       /* accumulate string lengths */
1685       if (i > 0)
1686          offsets[i] += offsets[i - 1];
1687    }
1688
1689    /* Total length of source string is sum off all strings plus two.
1690     * One extra byte for terminating zero, another extra byte to silence
1691     * valgrind warnings in the parser/grammer code.
1692     */
1693    totalLength = offsets[count - 1] + 2;
1694    source = malloc(totalLength * sizeof(GLcharARB));
1695    if (source == NULL) {
1696       free((GLvoid *) offsets);
1697       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1698       return;
1699    }
1700
1701    for (i = 0; i < count; i++) {
1702       GLint start = (i > 0) ? offsets[i - 1] : 0;
1703       memcpy(source + start, string[i],
1704              (offsets[i] - start) * sizeof(GLcharARB));
1705    }
1706    source[totalLength - 1] = '\0';
1707    source[totalLength - 2] = '\0';
1708
1709 #if defined(HAVE_SHA1)
1710    /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
1711     * if corresponding entry found from MESA_SHADER_READ_PATH.
1712     */
1713    dump_shader(sh->Stage, source);
1714
1715    replacement = read_shader(sh->Stage, source);
1716    if (replacement) {
1717       free(source);
1718       source = replacement;
1719    }
1720 #endif /* HAVE_SHA1 */
1721
1722    shader_source(sh, source);
1723
1724    free(offsets);
1725 }
1726
1727
1728 void GLAPIENTRY
1729 _mesa_UseProgram(GLhandleARB program)
1730 {
1731    GET_CURRENT_CONTEXT(ctx);
1732    struct gl_shader_program *shProg;
1733
1734    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1735       _mesa_error(ctx, GL_INVALID_OPERATION,
1736                   "glUseProgram(transform feedback active)");
1737       return;
1738    }
1739
1740    if (program) {
1741       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1742       if (!shProg) {
1743          return;
1744       }
1745       if (!shProg->LinkStatus) {
1746          _mesa_error(ctx, GL_INVALID_OPERATION,
1747                      "glUseProgram(program %u not linked)", program);
1748          return;
1749       }
1750
1751       /* debug code */
1752       if (ctx->_Shader->Flags & GLSL_USE_PROG) {
1753          print_shader_info(shProg);
1754       }
1755    }
1756    else {
1757       shProg = NULL;
1758    }
1759
1760    /* The ARB_separate_shader_object spec says:
1761     *
1762     *     "The executable code for an individual shader stage is taken from
1763     *     the current program for that stage.  If there is a current program
1764     *     object established by UseProgram, that program is considered current
1765     *     for all stages.  Otherwise, if there is a bound program pipeline
1766     *     object (section 2.14.PPO), the program bound to the appropriate
1767     *     stage of the pipeline object is considered current."
1768     */
1769    if (program) {
1770       /* Attach shader state to the binding point */
1771       _mesa_reference_pipeline_object(ctx, &ctx->_Shader, &ctx->Shader);
1772       /* Update the program */
1773       _mesa_use_program(ctx, shProg);
1774    } else {
1775       /* Must be done first: detach the progam */
1776       _mesa_use_program(ctx, shProg);
1777       /* Unattach shader_state binding point */
1778       _mesa_reference_pipeline_object(ctx, &ctx->_Shader, ctx->Pipeline.Default);
1779       /* If a pipeline was bound, rebind it */
1780       if (ctx->Pipeline.Current) {
1781          _mesa_BindProgramPipeline(ctx->Pipeline.Current->Name);
1782       }
1783    }
1784 }
1785
1786
1787 void GLAPIENTRY
1788 _mesa_ValidateProgram(GLhandleARB program)
1789 {
1790    GET_CURRENT_CONTEXT(ctx);
1791    validate_program(ctx, program);
1792 }
1793
1794
1795 /**
1796  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1797  */
1798 void GLAPIENTRY
1799 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1800                                GLint* range, GLint* precision)
1801 {
1802    const struct gl_program_constants *limits;
1803    const struct gl_precision *p;
1804    GET_CURRENT_CONTEXT(ctx);
1805
1806    switch (shadertype) {
1807    case GL_VERTEX_SHADER:
1808       limits = &ctx->Const.Program[MESA_SHADER_VERTEX];
1809       break;
1810    case GL_FRAGMENT_SHADER:
1811       limits = &ctx->Const.Program[MESA_SHADER_FRAGMENT];
1812       break;
1813    default:
1814       _mesa_error(ctx, GL_INVALID_ENUM,
1815                   "glGetShaderPrecisionFormat(shadertype)");
1816       return;
1817    }
1818
1819    switch (precisiontype) {
1820    case GL_LOW_FLOAT:
1821       p = &limits->LowFloat;
1822       break;
1823    case GL_MEDIUM_FLOAT:
1824       p = &limits->MediumFloat;
1825       break;
1826    case GL_HIGH_FLOAT:
1827       p = &limits->HighFloat;
1828       break;
1829    case GL_LOW_INT:
1830       p = &limits->LowInt;
1831       break;
1832    case GL_MEDIUM_INT:
1833       p = &limits->MediumInt;
1834       break;
1835    case GL_HIGH_INT:
1836       p = &limits->HighInt;
1837       break;
1838    default:
1839       _mesa_error(ctx, GL_INVALID_ENUM,
1840                   "glGetShaderPrecisionFormat(precisiontype)");
1841       return;
1842    }
1843
1844    range[0] = p->RangeMin;
1845    range[1] = p->RangeMax;
1846    precision[0] = p->Precision;
1847 }
1848
1849
1850 /**
1851  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1852  */
1853 void GLAPIENTRY
1854 _mesa_ReleaseShaderCompiler(void)
1855 {
1856    _mesa_destroy_shader_compiler_caches();
1857 }
1858
1859
1860 /**
1861  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1862  */
1863 void GLAPIENTRY
1864 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1865                    const void* binary, GLint length)
1866 {
1867    GET_CURRENT_CONTEXT(ctx);
1868    (void) shaders;
1869    (void) binaryformat;
1870    (void) binary;
1871
1872    /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
1873     * page 88 of the OpenGL 4.5 specs state:
1874     *
1875     *     "An INVALID_VALUE error is generated if count or length is negative.
1876     *      An INVALID_ENUM error is generated if binaryformat is not a supported
1877     *      format returned in SHADER_BINARY_FORMATS."
1878     */
1879    if (n < 0 || length < 0) {
1880       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderBinary(count or length < 0)");
1881       return;
1882    }
1883
1884    _mesa_error(ctx, GL_INVALID_ENUM, "glShaderBinary(format)");
1885 }
1886
1887
1888 void GLAPIENTRY
1889 _mesa_GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
1890                        GLenum *binaryFormat, GLvoid *binary)
1891 {
1892    struct gl_shader_program *shProg;
1893    GLsizei length_dummy;
1894    GET_CURRENT_CONTEXT(ctx);
1895
1896    if (bufSize < 0){
1897       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramBinary(bufSize < 0)");
1898       return;
1899    }
1900
1901    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetProgramBinary");
1902    if (!shProg)
1903       return;
1904
1905    /* The ARB_get_program_binary spec says:
1906     *
1907     *     "If <length> is NULL, then no length is returned."
1908     *
1909     * Ensure that length always points to valid storage to avoid multiple NULL
1910     * pointer checks below.
1911     */
1912    if (length == NULL)
1913       length = &length_dummy;
1914
1915
1916    /* The ARB_get_program_binary spec says:
1917     *
1918     *     "When a program object's LINK_STATUS is FALSE, its program binary
1919     *     length is zero, and a call to GetProgramBinary will generate an
1920     *     INVALID_OPERATION error.
1921     */
1922    if (!shProg->LinkStatus) {
1923       _mesa_error(ctx, GL_INVALID_OPERATION,
1924                   "glGetProgramBinary(program %u not linked)",
1925                   shProg->Name);
1926       *length = 0;
1927       return;
1928    }
1929
1930    *length = 0;
1931    _mesa_error(ctx, GL_INVALID_OPERATION,
1932                "glGetProgramBinary(driver supports zero binary formats)");
1933
1934    (void) binaryFormat;
1935    (void) binary;
1936 }
1937
1938 void GLAPIENTRY
1939 _mesa_ProgramBinary(GLuint program, GLenum binaryFormat,
1940                     const GLvoid *binary, GLsizei length)
1941 {
1942    struct gl_shader_program *shProg;
1943    GET_CURRENT_CONTEXT(ctx);
1944
1945    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramBinary");
1946    if (!shProg)
1947       return;
1948
1949    (void) binaryFormat;
1950    (void) binary;
1951
1952    /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
1953     *
1954     *     "If a negative number is provided where an argument of type sizei or
1955     *     sizeiptr is specified, an INVALID_VALUE error is generated."
1956     */
1957    if (length < 0) {
1958       _mesa_error(ctx, GL_INVALID_VALUE, "glProgramBinary(length < 0)");
1959       return;
1960    }
1961
1962    /* The ARB_get_program_binary spec says:
1963     *
1964     *     "<binaryFormat> and <binary> must be those returned by a previous
1965     *     call to GetProgramBinary, and <length> must be the length of the
1966     *     program binary as returned by GetProgramBinary or GetProgramiv with
1967     *     <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
1968     *     setting the LINK_STATUS of <program> to FALSE, if these conditions
1969     *     are not met."
1970     *
1971     * Since any value of binaryFormat passed "is not one of those specified as
1972     * allowable for [this] command, an INVALID_ENUM error is generated."
1973     */
1974    shProg->LinkStatus = GL_FALSE;
1975    _mesa_error(ctx, GL_INVALID_ENUM, "glProgramBinary");
1976 }
1977
1978
1979 void GLAPIENTRY
1980 _mesa_ProgramParameteri(GLuint program, GLenum pname, GLint value)
1981 {
1982    struct gl_shader_program *shProg;
1983    GET_CURRENT_CONTEXT(ctx);
1984
1985    shProg = _mesa_lookup_shader_program_err(ctx, program,
1986                                             "glProgramParameteri");
1987    if (!shProg)
1988       return;
1989
1990    switch (pname) {
1991    case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
1992       /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
1993        * is part of OpenGL ES 3.0.  For the ES2 case, this function shouldn't
1994        * even be in the dispatch table, so we shouldn't need to expclicitly
1995        * check here.
1996        *
1997        * On desktop, we ignore the 3.0+ requirement because it is silly.
1998        */
1999
2000       /* The ARB_get_program_binary extension spec says:
2001        *
2002        *     "An INVALID_VALUE error is generated if the <value> argument to
2003        *     ProgramParameteri is not TRUE or FALSE."
2004        */
2005       if (value != GL_TRUE && value != GL_FALSE) {
2006          goto invalid_value;
2007       }
2008
2009       /* No need to notify the driver.  Any changes will actually take effect
2010        * the next time the shader is linked.
2011        *
2012        * The ARB_get_program_binary extension spec says:
2013        *
2014        *     "To indicate that a program binary is likely to be retrieved,
2015        *     ProgramParameteri should be called with <pname>
2016        *     PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2017        *     will not be in effect until the next time LinkProgram or
2018        *     ProgramBinary has been called successfully."
2019        *
2020        * The resloution of issue 9 in the extension spec also says:
2021        *
2022        *     "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2023        *     to indicate to the GL implementation that this program will
2024        *     likely be saved with GetProgramBinary at some point. This will
2025        *     give the GL implementation the opportunity to track any state
2026        *     changes made to the program before being saved such that when it
2027        *     is loaded again a recompile can be avoided."
2028        */
2029       shProg->BinaryRetreivableHint = value;
2030       return;
2031
2032    case GL_PROGRAM_SEPARABLE:
2033       /* Spec imply that the behavior is the same as ARB_get_program_binary
2034        * Chapter 7.3 Program Objects
2035        */
2036       if (value != GL_TRUE && value != GL_FALSE) {
2037          goto invalid_value;
2038       }
2039       shProg->SeparateShader = value;
2040       return;
2041
2042    default:
2043       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteri(pname=%s)",
2044                   _mesa_enum_to_string(pname));
2045       return;
2046    }
2047
2048 invalid_value:
2049    _mesa_error(ctx, GL_INVALID_VALUE,
2050                "glProgramParameteri(pname=%s, value=%d): "
2051                "value must be 0 or 1.",
2052                _mesa_enum_to_string(pname),
2053                value);
2054 }
2055
2056
2057 void
2058 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
2059                          struct gl_shader_program *shProg,
2060                          struct gl_pipeline_object *shTarget)
2061 {
2062    gl_shader_stage stage = _mesa_shader_enum_to_shader_stage(type);
2063    use_shader_program(ctx, stage, shProg, shTarget);
2064
2065    if (ctx->Driver.UseProgram)
2066       ctx->Driver.UseProgram(ctx, shProg);
2067 }
2068
2069
2070 /**
2071  * Copy program-specific data generated by linking from the gl_shader_program
2072  * object to a specific gl_program object.
2073  */
2074 void
2075 _mesa_copy_linked_program_data(gl_shader_stage type,
2076                                const struct gl_shader_program *src,
2077                                struct gl_program *dst)
2078 {
2079    switch (type) {
2080    case MESA_SHADER_VERTEX:
2081       dst->ClipDistanceArraySize = src->Vert.ClipDistanceArraySize;
2082       break;
2083    case MESA_SHADER_TESS_CTRL: {
2084       struct gl_tess_ctrl_program *dst_tcp =
2085          (struct gl_tess_ctrl_program *) dst;
2086       dst_tcp->VerticesOut = src->TessCtrl.VerticesOut;
2087       break;
2088    }
2089    case MESA_SHADER_TESS_EVAL: {
2090       struct gl_tess_eval_program *dst_tep =
2091          (struct gl_tess_eval_program *) dst;
2092       dst_tep->PrimitiveMode = src->TessEval.PrimitiveMode;
2093       dst_tep->Spacing = src->TessEval.Spacing;
2094       dst_tep->VertexOrder = src->TessEval.VertexOrder;
2095       dst_tep->PointMode = src->TessEval.PointMode;
2096       dst->ClipDistanceArraySize = src->TessEval.ClipDistanceArraySize;
2097       break;
2098    }
2099    case MESA_SHADER_GEOMETRY: {
2100       struct gl_geometry_program *dst_gp = (struct gl_geometry_program *) dst;
2101       dst_gp->VerticesIn = src->Geom.VerticesIn;
2102       dst_gp->VerticesOut = src->Geom.VerticesOut;
2103       dst_gp->Invocations = src->Geom.Invocations;
2104       dst_gp->InputType = src->Geom.InputType;
2105       dst_gp->OutputType = src->Geom.OutputType;
2106       dst->ClipDistanceArraySize = src->Geom.ClipDistanceArraySize;
2107       dst_gp->UsesEndPrimitive = src->Geom.UsesEndPrimitive;
2108       dst_gp->UsesStreams = src->Geom.UsesStreams;
2109       break;
2110    }
2111    case MESA_SHADER_FRAGMENT: {
2112       struct gl_fragment_program *dst_fp = (struct gl_fragment_program *) dst;
2113       dst_fp->FragDepthLayout = src->FragDepthLayout;
2114       break;
2115    }
2116    case MESA_SHADER_COMPUTE: {
2117       struct gl_compute_program *dst_cp = (struct gl_compute_program *) dst;
2118       int i;
2119       for (i = 0; i < 3; i++)
2120          dst_cp->LocalSize[i] = src->Comp.LocalSize[i];
2121       break;
2122    }
2123    default:
2124       break;
2125    }
2126 }
2127
2128 /**
2129  * ARB_separate_shader_objects: Compile & Link Program
2130  */
2131 GLuint GLAPIENTRY
2132 _mesa_CreateShaderProgramv(GLenum type, GLsizei count,
2133                            const GLchar* const *strings)
2134 {
2135    GET_CURRENT_CONTEXT(ctx);
2136
2137    const GLuint shader = create_shader(ctx, type);
2138    GLuint program = 0;
2139
2140    /*
2141     * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2142     * GL_INVALID_VALUE should be generated if count < 0
2143     */
2144    if (count < 0) {
2145       _mesa_error(ctx, GL_INVALID_VALUE, "glCreateShaderProgram (count < 0)");
2146       return program;
2147    }
2148
2149    if (shader) {
2150       _mesa_ShaderSource(shader, count, strings, NULL);
2151
2152       compile_shader(ctx, shader);
2153
2154       program = create_shader_program(ctx);
2155       if (program) {
2156          struct gl_shader_program *shProg;
2157          struct gl_shader *sh;
2158          GLint compiled = GL_FALSE;
2159
2160          shProg = _mesa_lookup_shader_program(ctx, program);
2161          sh = _mesa_lookup_shader(ctx, shader);
2162
2163          shProg->SeparateShader = GL_TRUE;
2164
2165          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
2166          if (compiled) {
2167             attach_shader(ctx, program, shader);
2168             link_program(ctx, program);
2169             detach_shader(ctx, program, shader);
2170
2171 #if 0
2172             /* Possibly... */
2173             if (active-user-defined-varyings-in-linked-program) {
2174                append-error-to-info-log;
2175                shProg->LinkStatus = GL_FALSE;
2176             }
2177 #endif
2178          }
2179          if (sh->InfoLog)
2180             ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
2181       }
2182
2183       delete_shader(ctx, shader);
2184    }
2185
2186    return program;
2187 }
2188
2189
2190 /**
2191  * For GL_ARB_tessellation_shader
2192  */
2193 extern void GLAPIENTRY
2194 _mesa_PatchParameteri(GLenum pname, GLint value)
2195 {
2196    GET_CURRENT_CONTEXT(ctx);
2197
2198    if (!_mesa_has_tessellation(ctx)) {
2199       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameteri");
2200       return;
2201    }
2202
2203    if (pname != GL_PATCH_VERTICES) {
2204       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameteri");
2205       return;
2206    }
2207
2208    if (value <= 0 || value > ctx->Const.MaxPatchVertices) {
2209       _mesa_error(ctx, GL_INVALID_VALUE, "glPatchParameteri");
2210       return;
2211    }
2212
2213    ctx->TessCtrlProgram.patch_vertices = value;
2214 }
2215
2216
2217 extern void GLAPIENTRY
2218 _mesa_PatchParameterfv(GLenum pname, const GLfloat *values)
2219 {
2220    GET_CURRENT_CONTEXT(ctx);
2221
2222    if (!_mesa_has_tessellation(ctx)) {
2223       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameterfv");
2224       return;
2225    }
2226
2227    switch(pname) {
2228    case GL_PATCH_DEFAULT_OUTER_LEVEL:
2229       FLUSH_VERTICES(ctx, 0);
2230       memcpy(ctx->TessCtrlProgram.patch_default_outer_level, values,
2231              4 * sizeof(GLfloat));
2232       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2233       return;
2234    case GL_PATCH_DEFAULT_INNER_LEVEL:
2235       FLUSH_VERTICES(ctx, 0);
2236       memcpy(ctx->TessCtrlProgram.patch_default_inner_level, values,
2237              2 * sizeof(GLfloat));
2238       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2239       return;
2240    default:
2241       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameterfv");
2242       return;
2243    }
2244 }
2245
2246 /**
2247  * ARB_shader_subroutine
2248  */
2249 GLint GLAPIENTRY
2250 _mesa_GetSubroutineUniformLocation(GLuint program, GLenum shadertype,
2251                                    const GLchar *name)
2252 {
2253    GET_CURRENT_CONTEXT(ctx);
2254    const char *api_name = "glGetSubroutineUniformLocation";
2255    struct gl_shader_program *shProg;
2256    GLenum resource_type;
2257    gl_shader_stage stage;
2258
2259    if (!_mesa_has_shader_subroutine(ctx)) {
2260       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2261       return -1;
2262    }
2263
2264    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2265       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2266       return -1;
2267    }
2268
2269    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2270    if (!shProg)
2271       return -1;
2272
2273    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2274    if (!shProg->_LinkedShaders[stage]) {
2275       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2276       return -1;
2277    }
2278
2279    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2280    return _mesa_program_resource_location(shProg, resource_type, name);
2281 }
2282
2283 GLuint GLAPIENTRY
2284 _mesa_GetSubroutineIndex(GLuint program, GLenum shadertype,
2285                          const GLchar *name)
2286 {
2287    GET_CURRENT_CONTEXT(ctx);
2288    const char *api_name = "glGetSubroutineIndex";
2289    struct gl_shader_program *shProg;
2290    struct gl_program_resource *res;
2291    GLenum resource_type;
2292    gl_shader_stage stage;
2293
2294    if (!_mesa_has_shader_subroutine(ctx)) {
2295       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2296       return -1;
2297    }
2298
2299    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2300       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2301       return -1;
2302    }
2303
2304    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2305    if (!shProg)
2306       return -1;
2307
2308    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2309    if (!shProg->_LinkedShaders[stage]) {
2310       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2311       return -1;
2312    }
2313
2314    resource_type = _mesa_shader_stage_to_subroutine(stage);
2315    res = _mesa_program_resource_find_name(shProg, resource_type, name, NULL);
2316    if (!res) {
2317       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2318      return -1;
2319    }
2320
2321    return _mesa_program_resource_index(shProg, res);
2322 }
2323
2324
2325 GLvoid GLAPIENTRY
2326 _mesa_GetActiveSubroutineUniformiv(GLuint program, GLenum shadertype,
2327                                    GLuint index, GLenum pname, GLint *values)
2328 {
2329    GET_CURRENT_CONTEXT(ctx);
2330    const char *api_name = "glGetActiveSubroutineUniformiv";
2331    struct gl_shader_program *shProg;
2332    struct gl_shader *sh;
2333    gl_shader_stage stage;
2334    struct gl_program_resource *res;
2335    const struct gl_uniform_storage *uni;
2336    GLenum resource_type;
2337    int count, i, j;
2338
2339    if (!_mesa_has_shader_subroutine(ctx)) {
2340       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2341       return;
2342    }
2343
2344    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2345       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2346       return;
2347    }
2348
2349    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2350    if (!shProg)
2351       return;
2352
2353    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2354    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2355
2356    sh = shProg->_LinkedShaders[stage];
2357    if (!sh) {
2358       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2359       return;
2360    }
2361
2362    switch (pname) {
2363    case GL_NUM_COMPATIBLE_SUBROUTINES: {
2364       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2365       if (res) {
2366          uni = res->Data;
2367          values[0] = uni->num_compatible_subroutines;
2368       }
2369       break;
2370    }
2371    case GL_COMPATIBLE_SUBROUTINES: {
2372       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2373       if (res) {
2374          uni = res->Data;
2375          count = 0;
2376          for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2377             struct gl_subroutine_function *fn = &sh->SubroutineFunctions[i];
2378             for (j = 0; j < fn->num_compat_types; j++) {
2379                if (fn->types[j] == uni->type) {
2380                   values[count++] = i;
2381                   break;
2382                }
2383             }
2384          }
2385       }
2386       break;
2387    }
2388    case GL_UNIFORM_SIZE:
2389       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2390       if (res) {
2391          uni = res->Data;
2392          values[0] = uni->array_elements ? uni->array_elements : 1;
2393       }
2394       break;
2395    case GL_UNIFORM_NAME_LENGTH:
2396       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2397       if (res) {
2398          values[0] = strlen(_mesa_program_resource_name(res)) + 1
2399             + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);;
2400       }
2401       break;
2402    default:
2403       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2404       return;
2405    }
2406 }
2407
2408
2409 GLvoid GLAPIENTRY
2410 _mesa_GetActiveSubroutineUniformName(GLuint program, GLenum shadertype,
2411                                      GLuint index, GLsizei bufsize,
2412                                      GLsizei *length, GLchar *name)
2413 {
2414    GET_CURRENT_CONTEXT(ctx);
2415    const char *api_name = "glGetActiveSubroutineUniformName";
2416    struct gl_shader_program *shProg;
2417    GLenum resource_type;
2418    gl_shader_stage stage;
2419
2420    if (!_mesa_has_shader_subroutine(ctx)) {
2421       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2422       return;
2423    }
2424
2425    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2426       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2427       return;
2428    }
2429
2430    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2431    if (!shProg)
2432       return;
2433
2434    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2435    if (!shProg->_LinkedShaders[stage]) {
2436       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2437       return;
2438    }
2439
2440    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2441    /* get program resource name */
2442    _mesa_get_program_resource_name(shProg, resource_type,
2443                                    index, bufsize,
2444                                    length, name, api_name);
2445 }
2446
2447
2448 GLvoid GLAPIENTRY
2449 _mesa_GetActiveSubroutineName(GLuint program, GLenum shadertype,
2450                               GLuint index, GLsizei bufsize,
2451                               GLsizei *length, GLchar *name)
2452 {
2453    GET_CURRENT_CONTEXT(ctx);
2454    const char *api_name = "glGetActiveSubroutineName";
2455    struct gl_shader_program *shProg;
2456    GLenum resource_type;
2457    gl_shader_stage stage;
2458
2459    if (!_mesa_has_shader_subroutine(ctx)) {
2460       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2461       return;
2462    }
2463
2464    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2465       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2466       return;
2467    }
2468
2469    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2470    if (!shProg)
2471       return;
2472
2473    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2474    if (!shProg->_LinkedShaders[stage]) {
2475       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2476       return;
2477    }
2478    resource_type = _mesa_shader_stage_to_subroutine(stage);
2479    _mesa_get_program_resource_name(shProg, resource_type,
2480                                    index, bufsize,
2481                                    length, name, api_name);
2482 }
2483
2484
2485 GLvoid GLAPIENTRY
2486 _mesa_UniformSubroutinesuiv(GLenum shadertype, GLsizei count,
2487                             const GLuint *indices)
2488 {
2489    GET_CURRENT_CONTEXT(ctx);
2490    const char *api_name = "glUniformSubroutinesuiv";
2491    struct gl_shader_program *shProg;
2492    struct gl_shader *sh;
2493    gl_shader_stage stage;
2494    int i;
2495
2496    if (!_mesa_has_shader_subroutine(ctx)) {
2497       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2498       return;
2499    }
2500
2501    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2502       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2503       return;
2504    }
2505
2506    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2507    shProg = ctx->_Shader->CurrentProgram[stage];
2508    if (!shProg) {
2509       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2510       return;
2511    }
2512
2513    sh = shProg->_LinkedShaders[stage];
2514    if (!sh) {
2515       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2516       return;
2517    }
2518
2519    if (count != sh->NumSubroutineUniformRemapTable) {
2520       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2521       return;
2522    }
2523
2524    i = 0;
2525    do {
2526       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2527       int uni_count = uni->array_elements ? uni->array_elements : 1;
2528       int j, k;
2529
2530       for (j = i; j < i + uni_count; j++) {
2531          struct gl_subroutine_function *subfn;
2532          if (indices[j] >= sh->NumSubroutineFunctions) {
2533             _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2534             return;
2535          }
2536
2537          subfn = &sh->SubroutineFunctions[indices[j]];
2538          for (k = 0; k < subfn->num_compat_types; k++) {
2539             if (subfn->types[k] == uni->type)
2540                break;
2541          }
2542          if (k == subfn->num_compat_types) {
2543             _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2544             return;
2545          }
2546       }
2547       i += uni_count;
2548    } while(i < count);
2549
2550    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
2551    i = 0;
2552    do {
2553       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2554       int uni_count = uni->array_elements ? uni->array_elements : 1;
2555
2556       memcpy(&uni->storage[0], &indices[i],
2557              sizeof(GLuint) * uni_count);
2558
2559       uni->initialized = true;
2560       _mesa_propagate_uniforms_to_driver_storage(uni, 0, uni_count);
2561       i += uni_count;
2562    } while(i < count);
2563 }
2564
2565
2566 GLvoid GLAPIENTRY
2567 _mesa_GetUniformSubroutineuiv(GLenum shadertype, GLint location,
2568                               GLuint *params)
2569 {
2570    GET_CURRENT_CONTEXT(ctx);
2571    const char *api_name = "glGetUniformSubroutineuiv";
2572    struct gl_shader_program *shProg;
2573    struct gl_shader *sh;
2574    gl_shader_stage stage;
2575
2576    if (!_mesa_has_shader_subroutine(ctx)) {
2577       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2578       return;
2579    }
2580
2581    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2582       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2583       return;
2584    }
2585
2586    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2587    shProg = ctx->_Shader->CurrentProgram[stage];
2588    if (!shProg) {
2589       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2590       return;
2591    }
2592
2593    sh = shProg->_LinkedShaders[stage];
2594    if (!sh) {
2595       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2596       return;
2597    }
2598
2599    if (location >= sh->NumSubroutineUniformRemapTable) {
2600       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2601       return;
2602    }
2603
2604    {
2605       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[location];
2606       int offset = location - uni->opaque[stage].index;
2607       memcpy(params, &uni->storage[offset],
2608              sizeof(GLuint));
2609    }
2610 }
2611
2612
2613 GLvoid GLAPIENTRY
2614 _mesa_GetProgramStageiv(GLuint program, GLenum shadertype,
2615                         GLenum pname, GLint *values)
2616 {
2617    GET_CURRENT_CONTEXT(ctx);
2618    const char *api_name = "glGetProgramStageiv";
2619    struct gl_shader_program *shProg;
2620    struct gl_shader *sh;
2621    gl_shader_stage stage;
2622
2623    if (!_mesa_has_shader_subroutine(ctx)) {
2624       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2625       return;
2626    }
2627
2628    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2629       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2630       return;
2631    }
2632
2633    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2634    if (!shProg)
2635       return;
2636
2637    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2638    sh = shProg->_LinkedShaders[stage];
2639    if (!sh) {
2640       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2641       return;
2642    }
2643
2644    switch (pname) {
2645    case GL_ACTIVE_SUBROUTINES:
2646       values[0] = sh->NumSubroutineFunctions;
2647       break;
2648    case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS:
2649       values[0] = sh->NumSubroutineUniformRemapTable;
2650       break;
2651    case GL_ACTIVE_SUBROUTINE_UNIFORMS:
2652       values[0] = sh->NumSubroutineUniformTypes;
2653       break;
2654    case GL_ACTIVE_SUBROUTINE_MAX_LENGTH:
2655    {
2656       unsigned i;
2657       GLint max_len = 0;
2658       GLenum resource_type;
2659       struct gl_program_resource *res;
2660
2661       resource_type = _mesa_shader_stage_to_subroutine(stage);
2662       for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2663          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2664          if (res) {
2665             const GLint len = strlen(_mesa_program_resource_name(res)) + 1;
2666             if (len > max_len)
2667                max_len = len;
2668          }
2669       }
2670       values[0] = max_len;
2671       break;
2672    }
2673    case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH:
2674    {
2675       unsigned i;
2676       GLint max_len = 0;
2677       GLenum resource_type;
2678       struct gl_program_resource *res;
2679
2680       resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2681       for (i = 0; i < sh->NumSubroutineUniformRemapTable; i++) {
2682          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2683          if (res) {
2684             const GLint len = strlen(_mesa_program_resource_name(res)) + 1
2685                + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);
2686
2687             if (len > max_len)
2688                max_len = len;
2689          }
2690       }
2691       values[0] = max_len;
2692       break;
2693    }
2694    default:
2695       _mesa_error(ctx, GL_INVALID_ENUM, "%s", api_name);
2696       values[0] = -1;
2697       break;
2698    }
2699 }
2700
2701 static int
2702 find_compat_subroutine(struct gl_shader *sh, const struct glsl_type *type)
2703 {
2704    int i, j;
2705
2706    for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2707       struct gl_subroutine_function *fn = &sh->SubroutineFunctions[i];
2708       for (j = 0; j < fn->num_compat_types; j++) {
2709          if (fn->types[j] == type)
2710             return i;
2711       }
2712    }
2713    return 0;
2714 }
2715
2716 static void
2717 _mesa_shader_init_subroutine_defaults(struct gl_shader *sh)
2718 {
2719    int i, j;
2720
2721    for (i = 0; i < sh->NumSubroutineUniformRemapTable; i++) {
2722       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2723       int uni_count;
2724       int val;
2725
2726       if (!uni)
2727          continue;
2728       uni_count = uni->array_elements ? uni->array_elements : 1;
2729       val = find_compat_subroutine(sh, uni->type);
2730
2731       for (j = 0; j < uni_count; j++)
2732          memcpy(&uni->storage[j], &val, sizeof(int));
2733       uni->initialized = true;
2734       _mesa_propagate_uniforms_to_driver_storage(uni, 0, uni_count);
2735    }
2736 }
2737
2738 void
2739 _mesa_shader_program_init_subroutine_defaults(struct gl_shader_program *shProg)
2740 {
2741    int i;
2742
2743    if (!shProg)
2744       return;
2745
2746    for (i = 0; i < MESA_SHADER_STAGES; i++) {
2747       if (!shProg->_LinkedShaders[i])
2748          continue;
2749
2750       _mesa_shader_init_subroutine_defaults(shProg->_LinkedShaders[i]);
2751    }
2752 }