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