src/mesa/main/shaderapi.c

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