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