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