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