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