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