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