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.post_depth_coverage = dst_sh->info.PostDepthCoverage;
2198       break;
2199    }
2200    case MESA_SHADER_COMPUTE: {
2201       for (int i = 0; i < 3; i++)
2202          dst->info.cs.local_size[i] = src->Comp.LocalSize[i];
2203       dst->info.cs.shared_size = src->Comp.SharedSize;
2204       break;
2205    }
2206    default:
2207       break;
2208    }
2209 }
2210
2211 /**
2212  * ARB_separate_shader_objects: Compile & Link Program
2213  */
2214 GLuint GLAPIENTRY
2215 _mesa_CreateShaderProgramv(GLenum type, GLsizei count,
2216                            const GLchar* const *strings)
2217 {
2218    GET_CURRENT_CONTEXT(ctx);
2219
2220    const GLuint shader = create_shader(ctx, type);
2221    GLuint program = 0;
2222
2223    /*
2224     * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2225     * GL_INVALID_VALUE should be generated if count < 0
2226     */
2227    if (count < 0) {
2228       _mesa_error(ctx, GL_INVALID_VALUE, "glCreateShaderProgram (count < 0)");
2229       return program;
2230    }
2231
2232    if (shader) {
2233       struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
2234
2235       _mesa_ShaderSource(shader, count, strings, NULL);
2236       _mesa_compile_shader(ctx, sh);
2237
2238       program = create_shader_program(ctx);
2239       if (program) {
2240          struct gl_shader_program *shProg;
2241          GLint compiled = GL_FALSE;
2242
2243          shProg = _mesa_lookup_shader_program(ctx, program);
2244
2245          shProg->SeparateShader = GL_TRUE;
2246
2247          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
2248          if (compiled) {
2249             attach_shader(ctx, program, shader);
2250             _mesa_link_program(ctx, shProg);
2251             detach_shader(ctx, program, shader);
2252
2253 #if 0
2254             /* Possibly... */
2255             if (active-user-defined-varyings-in-linked-program) {
2256                append-error-to-info-log;
2257                shProg->data->LinkStatus = GL_FALSE;
2258             }
2259 #endif
2260          }
2261          if (sh->InfoLog)
2262             ralloc_strcat(&shProg->data->InfoLog, sh->InfoLog);
2263       }
2264
2265       delete_shader(ctx, shader);
2266    }
2267
2268    return program;
2269 }
2270
2271
2272 /**
2273  * For GL_ARB_tessellation_shader
2274  */
2275 extern void GLAPIENTRY
2276 _mesa_PatchParameteri(GLenum pname, GLint value)
2277 {
2278    GET_CURRENT_CONTEXT(ctx);
2279
2280    if (!_mesa_has_tessellation(ctx)) {
2281       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameteri");
2282       return;
2283    }
2284
2285    if (pname != GL_PATCH_VERTICES) {
2286       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameteri");
2287       return;
2288    }
2289
2290    if (value <= 0 || value > ctx->Const.MaxPatchVertices) {
2291       _mesa_error(ctx, GL_INVALID_VALUE, "glPatchParameteri");
2292       return;
2293    }
2294
2295    ctx->TessCtrlProgram.patch_vertices = value;
2296 }
2297
2298
2299 extern void GLAPIENTRY
2300 _mesa_PatchParameterfv(GLenum pname, const GLfloat *values)
2301 {
2302    GET_CURRENT_CONTEXT(ctx);
2303
2304    if (!_mesa_has_tessellation(ctx)) {
2305       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameterfv");
2306       return;
2307    }
2308
2309    switch(pname) {
2310    case GL_PATCH_DEFAULT_OUTER_LEVEL:
2311       FLUSH_VERTICES(ctx, 0);
2312       memcpy(ctx->TessCtrlProgram.patch_default_outer_level, values,
2313              4 * sizeof(GLfloat));
2314       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2315       return;
2316    case GL_PATCH_DEFAULT_INNER_LEVEL:
2317       FLUSH_VERTICES(ctx, 0);
2318       memcpy(ctx->TessCtrlProgram.patch_default_inner_level, values,
2319              2 * sizeof(GLfloat));
2320       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2321       return;
2322    default:
2323       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameterfv");
2324       return;
2325    }
2326 }
2327
2328 /**
2329  * ARB_shader_subroutine
2330  */
2331 GLint GLAPIENTRY
2332 _mesa_GetSubroutineUniformLocation(GLuint program, GLenum shadertype,
2333                                    const GLchar *name)
2334 {
2335    GET_CURRENT_CONTEXT(ctx);
2336    const char *api_name = "glGetSubroutineUniformLocation";
2337    struct gl_shader_program *shProg;
2338    GLenum resource_type;
2339    gl_shader_stage stage;
2340
2341    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2342       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2343       return -1;
2344    }
2345
2346    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2347       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2348       return -1;
2349    }
2350
2351    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2352    if (!shProg)
2353       return -1;
2354
2355    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2356    if (!shProg->_LinkedShaders[stage]) {
2357       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2358       return -1;
2359    }
2360
2361    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2362    return _mesa_program_resource_location(shProg, resource_type, name);
2363 }
2364
2365 GLuint GLAPIENTRY
2366 _mesa_GetSubroutineIndex(GLuint program, GLenum shadertype,
2367                          const GLchar *name)
2368 {
2369    GET_CURRENT_CONTEXT(ctx);
2370    const char *api_name = "glGetSubroutineIndex";
2371    struct gl_shader_program *shProg;
2372    struct gl_program_resource *res;
2373    GLenum resource_type;
2374    gl_shader_stage stage;
2375
2376    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2377       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2378       return -1;
2379    }
2380
2381    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2382       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2383       return -1;
2384    }
2385
2386    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2387    if (!shProg)
2388       return -1;
2389
2390    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2391    if (!shProg->_LinkedShaders[stage]) {
2392       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2393       return -1;
2394    }
2395
2396    resource_type = _mesa_shader_stage_to_subroutine(stage);
2397    res = _mesa_program_resource_find_name(shProg, resource_type, name, NULL);
2398    if (!res) {
2399      return -1;
2400    }
2401
2402    return _mesa_program_resource_index(shProg, res);
2403 }
2404
2405
2406 GLvoid GLAPIENTRY
2407 _mesa_GetActiveSubroutineUniformiv(GLuint program, GLenum shadertype,
2408                                    GLuint index, GLenum pname, GLint *values)
2409 {
2410    GET_CURRENT_CONTEXT(ctx);
2411    const char *api_name = "glGetActiveSubroutineUniformiv";
2412    struct gl_shader_program *shProg;
2413    struct gl_linked_shader *sh;
2414    gl_shader_stage stage;
2415    struct gl_program_resource *res;
2416    const struct gl_uniform_storage *uni;
2417    GLenum resource_type;
2418    int count, i, j;
2419
2420    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2421       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2422       return;
2423    }
2424
2425    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2426       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2427       return;
2428    }
2429
2430    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2431    if (!shProg)
2432       return;
2433
2434    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2435    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2436
2437    sh = shProg->_LinkedShaders[stage];
2438    if (!sh) {
2439       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2440       return;
2441    }
2442
2443    if (index >= sh->NumSubroutineUniforms) {
2444       _mesa_error(ctx, GL_INVALID_VALUE, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name);
2445       return;
2446    }
2447
2448    switch (pname) {
2449    case GL_NUM_COMPATIBLE_SUBROUTINES: {
2450       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2451       if (res) {
2452          uni = res->Data;
2453          values[0] = uni->num_compatible_subroutines;
2454       }
2455       break;
2456    }
2457    case GL_COMPATIBLE_SUBROUTINES: {
2458       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2459       if (res) {
2460          uni = res->Data;
2461          count = 0;
2462          for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2463             struct gl_subroutine_function *fn = &sh->SubroutineFunctions[i];
2464             for (j = 0; j < fn->num_compat_types; j++) {
2465                if (fn->types[j] == uni->type) {
2466                   values[count++] = i;
2467                   break;
2468                }
2469             }
2470          }
2471       }
2472       break;
2473    }
2474    case GL_UNIFORM_SIZE:
2475       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2476       if (res) {
2477          uni = res->Data;
2478          values[0] = uni->array_elements ? uni->array_elements : 1;
2479       }
2480       break;
2481    case GL_UNIFORM_NAME_LENGTH:
2482       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2483       if (res) {
2484          values[0] = strlen(_mesa_program_resource_name(res)) + 1
2485             + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);
2486       }
2487       break;
2488    default:
2489       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2490       return;
2491    }
2492 }
2493
2494
2495 GLvoid GLAPIENTRY
2496 _mesa_GetActiveSubroutineUniformName(GLuint program, GLenum shadertype,
2497                                      GLuint index, GLsizei bufsize,
2498                                      GLsizei *length, GLchar *name)
2499 {
2500    GET_CURRENT_CONTEXT(ctx);
2501    const char *api_name = "glGetActiveSubroutineUniformName";
2502    struct gl_shader_program *shProg;
2503    GLenum resource_type;
2504    gl_shader_stage stage;
2505
2506    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2507       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2508       return;
2509    }
2510
2511    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2512       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2513       return;
2514    }
2515
2516    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2517    if (!shProg)
2518       return;
2519
2520    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2521    if (!shProg->_LinkedShaders[stage]) {
2522       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2523       return;
2524    }
2525
2526    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2527    /* get program resource name */
2528    _mesa_get_program_resource_name(shProg, resource_type,
2529                                    index, bufsize,
2530                                    length, name, api_name);
2531 }
2532
2533
2534 GLvoid GLAPIENTRY
2535 _mesa_GetActiveSubroutineName(GLuint program, GLenum shadertype,
2536                               GLuint index, GLsizei bufsize,
2537                               GLsizei *length, GLchar *name)
2538 {
2539    GET_CURRENT_CONTEXT(ctx);
2540    const char *api_name = "glGetActiveSubroutineName";
2541    struct gl_shader_program *shProg;
2542    GLenum resource_type;
2543    gl_shader_stage stage;
2544
2545    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2546       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2547       return;
2548    }
2549
2550    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2551       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2552       return;
2553    }
2554
2555    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2556    if (!shProg)
2557       return;
2558
2559    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2560    if (!shProg->_LinkedShaders[stage]) {
2561       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2562       return;
2563    }
2564    resource_type = _mesa_shader_stage_to_subroutine(stage);
2565    _mesa_get_program_resource_name(shProg, resource_type,
2566                                    index, bufsize,
2567                                    length, name, api_name);
2568 }
2569
2570 GLvoid GLAPIENTRY
2571 _mesa_UniformSubroutinesuiv(GLenum shadertype, GLsizei count,
2572                             const GLuint *indices)
2573 {
2574    GET_CURRENT_CONTEXT(ctx);
2575    const char *api_name = "glUniformSubroutinesuiv";
2576    struct gl_shader_program *shProg;
2577    struct gl_linked_shader *sh;
2578    gl_shader_stage stage;
2579    int i;
2580
2581    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2582       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2583       return;
2584    }
2585
2586    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2587       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2588       return;
2589    }
2590
2591    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2592    shProg = ctx->_Shader->CurrentProgram[stage];
2593    if (!shProg) {
2594       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2595       return;
2596    }
2597
2598    sh = shProg->_LinkedShaders[stage];
2599    if (!sh) {
2600       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2601       return;
2602    }
2603
2604    if (count != sh->NumSubroutineUniformRemapTable) {
2605       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2606       return;
2607    }
2608
2609    i = 0;
2610    do {
2611       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2612       if (uni == NULL) {
2613          i++;
2614          continue;
2615       }
2616
2617       int uni_count = uni->array_elements ? uni->array_elements : 1;
2618       int j, k, f;
2619
2620       for (j = i; j < i + uni_count; j++) {
2621          struct gl_subroutine_function *subfn = NULL;
2622          if (indices[j] > sh->MaxSubroutineFunctionIndex) {
2623             _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2624             return;
2625          }
2626
2627          for (f = 0; f < sh->NumSubroutineFunctions; f++) {
2628             if (sh->SubroutineFunctions[f].index == indices[j])
2629                subfn = &sh->SubroutineFunctions[f];
2630          }
2631
2632          if (!subfn) {
2633             continue;
2634          }
2635
2636          for (k = 0; k < subfn->num_compat_types; k++) {
2637             if (subfn->types[k] == uni->type)
2638                break;
2639          }
2640          if (k == subfn->num_compat_types) {
2641             _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2642             return;
2643          }
2644
2645          ctx->SubroutineIndex[sh->Stage].IndexPtr[j] = indices[j];
2646       }
2647       i += uni_count;
2648    } while(i < count);
2649
2650    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
2651 }
2652
2653
2654 GLvoid GLAPIENTRY
2655 _mesa_GetUniformSubroutineuiv(GLenum shadertype, GLint location,
2656                               GLuint *params)
2657 {
2658    GET_CURRENT_CONTEXT(ctx);
2659    const char *api_name = "glGetUniformSubroutineuiv";
2660    struct gl_shader_program *shProg;
2661    struct gl_linked_shader *sh;
2662    gl_shader_stage stage;
2663
2664    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2665       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2666       return;
2667    }
2668
2669    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2670       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2671       return;
2672    }
2673
2674    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2675    shProg = ctx->_Shader->CurrentProgram[stage];
2676    if (!shProg) {
2677       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2678       return;
2679    }
2680
2681    sh = shProg->_LinkedShaders[stage];
2682    if (!sh) {
2683       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2684       return;
2685    }
2686
2687    if (location >= sh->NumSubroutineUniformRemapTable) {
2688       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2689       return;
2690    }
2691
2692    *params = ctx->SubroutineIndex[sh->Stage].IndexPtr[location];
2693 }
2694
2695
2696 GLvoid GLAPIENTRY
2697 _mesa_GetProgramStageiv(GLuint program, GLenum shadertype,
2698                         GLenum pname, GLint *values)
2699 {
2700    GET_CURRENT_CONTEXT(ctx);
2701    const char *api_name = "glGetProgramStageiv";
2702    struct gl_shader_program *shProg;
2703    struct gl_linked_shader *sh;
2704    gl_shader_stage stage;
2705
2706    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2707       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2708       return;
2709    }
2710
2711    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2712       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2713       return;
2714    }
2715
2716    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2717    if (!shProg)
2718       return;
2719
2720    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2721    sh = shProg->_LinkedShaders[stage];
2722
2723    /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
2724     * INVALID_OPERATION in the case of not be linked.
2725     *
2726     * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
2727     * same info using other specs (ARB_program_interface_query), without the
2728     * need of the program to be linked, being the value for that case 0.
2729     *
2730     * But at the same time, some other methods require the program to be
2731     * linked for pname related to locations, so it would be inconsistent to
2732     * not do the same here. So we are:
2733     *   * Return GL_INVALID_OPERATION if not linked only for locations.
2734     *   * Setting a default value of 0, to be returned if not linked.
2735     */
2736    if (!sh) {
2737       values[0] = 0;
2738       if (pname == GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS) {
2739          _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2740       }
2741       return;
2742    }
2743
2744    switch (pname) {
2745    case GL_ACTIVE_SUBROUTINES:
2746       values[0] = sh->NumSubroutineFunctions;
2747       break;
2748    case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS:
2749       values[0] = sh->NumSubroutineUniformRemapTable;
2750       break;
2751    case GL_ACTIVE_SUBROUTINE_UNIFORMS:
2752       values[0] = sh->NumSubroutineUniforms;
2753       break;
2754    case GL_ACTIVE_SUBROUTINE_MAX_LENGTH:
2755    {
2756       unsigned i;
2757       GLint max_len = 0;
2758       GLenum resource_type;
2759       struct gl_program_resource *res;
2760
2761       resource_type = _mesa_shader_stage_to_subroutine(stage);
2762       for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2763          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2764          if (res) {
2765             const GLint len = strlen(_mesa_program_resource_name(res)) + 1;
2766             if (len > max_len)
2767                max_len = len;
2768          }
2769       }
2770       values[0] = max_len;
2771       break;
2772    }
2773    case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH:
2774    {
2775       unsigned i;
2776       GLint max_len = 0;
2777       GLenum resource_type;
2778       struct gl_program_resource *res;
2779
2780       resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2781       for (i = 0; i < sh->NumSubroutineUniformRemapTable; i++) {
2782          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2783          if (res) {
2784             const GLint len = strlen(_mesa_program_resource_name(res)) + 1
2785                + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);
2786
2787             if (len > max_len)
2788                max_len = len;
2789          }
2790       }
2791       values[0] = max_len;
2792       break;
2793    }
2794    default:
2795       _mesa_error(ctx, GL_INVALID_ENUM, "%s", api_name);
2796       values[0] = -1;
2797       break;
2798    }
2799 }
2800
2801 static int
2802 find_compat_subroutine(struct gl_linked_shader *sh,
2803                        const struct glsl_type *type)
2804 {
2805    int i, j;
2806
2807    for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2808       struct gl_subroutine_function *fn = &sh->SubroutineFunctions[i];
2809       for (j = 0; j < fn->num_compat_types; j++) {
2810          if (fn->types[j] == type)
2811             return i;
2812       }
2813    }
2814    return 0;
2815 }
2816
2817 static void
2818 _mesa_shader_write_subroutine_index(struct gl_context *ctx,
2819                                     struct gl_linked_shader *sh)
2820 {
2821    int i, j;
2822
2823    if (sh->NumSubroutineUniformRemapTable == 0)
2824       return;
2825
2826    i = 0;
2827    do {
2828       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2829       int uni_count;
2830       int val;
2831
2832       if (!uni) {
2833          i++;
2834          continue;
2835       }
2836
2837       uni_count = uni->array_elements ? uni->array_elements : 1;
2838       for (j = 0; j < uni_count; j++) {
2839          val = ctx->SubroutineIndex[sh->Stage].IndexPtr[i + j];
2840          memcpy(&uni->storage[j], &val, sizeof(int));
2841       }
2842
2843       _mesa_propagate_uniforms_to_driver_storage(uni, 0, uni_count);
2844       i += uni_count;
2845    } while(i < sh->NumSubroutineUniformRemapTable);
2846 }
2847
2848 void
2849 _mesa_shader_write_subroutine_indices(struct gl_context *ctx,
2850                                       gl_shader_stage stage)
2851 {
2852    if (ctx->_Shader->CurrentProgram[stage] &&
2853        ctx->_Shader->CurrentProgram[stage]->_LinkedShaders[stage])
2854       _mesa_shader_write_subroutine_index(ctx,
2855                                           ctx->_Shader->CurrentProgram[stage]->_LinkedShaders[stage]);
2856 }
2857
2858 static void
2859 _mesa_shader_init_subroutine_defaults(struct gl_context *ctx,
2860                                       struct gl_linked_shader *sh)
2861 {
2862    int i;
2863    struct gl_subroutine_index_binding *binding = &ctx->SubroutineIndex[sh->Stage];
2864    if (binding->NumIndex != sh->NumSubroutineUniformRemapTable) {
2865       binding->IndexPtr = realloc(binding->IndexPtr,
2866                                   sh->NumSubroutineUniformRemapTable * (sizeof(GLuint)));
2867       binding->NumIndex = sh->NumSubroutineUniformRemapTable;
2868    }
2869
2870    for (i = 0; i < sh->NumSubroutineUniformRemapTable; i++) {
2871       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2872
2873       if (!uni)
2874          continue;
2875
2876       binding->IndexPtr[i] = find_compat_subroutine(sh, uni->type);
2877    }
2878 }
2879
2880 void
2881 _mesa_shader_program_init_subroutine_defaults(struct gl_context *ctx,
2882                                               struct gl_shader_program *shProg)
2883 {
2884    int i;
2885
2886    if (!shProg)
2887       return;
2888
2889    for (i = 0; i < MESA_SHADER_STAGES; i++) {
2890       if (!shProg->_LinkedShaders[i])
2891          continue;
2892
2893       _mesa_shader_init_subroutine_defaults(ctx, shProg->_LinkedShaders[i]);
2894    }
2895 }