src/mesa/main/shaderapi.c

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