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             if (sh->ir) {
1043                _mesa_log("GLSL IR for shader %d:\n", sh->Name);
1044                _mesa_print_ir(_mesa_get_log_file(), sh->ir, NULL);
1045             } else {
1046                _mesa_log("No GLSL IR for shader %d (shader may be from "
1047                          "cache)\n", sh->Name);
1048             }
1049             _mesa_log("\n\n");
1050          } else {
1051             _mesa_log("GLSL shader %d failed to compile.\n", sh->Name);
1052          }
1053          if (sh->InfoLog && sh->InfoLog[0] != 0) {
1054             _mesa_log("GLSL shader %d info log:\n", sh->Name);
1055             _mesa_log("%s\n", sh->InfoLog);
1056          }
1057       }
1058    }
1059
1060    if (!sh->CompileStatus) {
1061       if (ctx->_Shader->Flags & GLSL_DUMP_ON_ERROR) {
1062          _mesa_log("GLSL source for %s shader %d:\n",
1063                  _mesa_shader_stage_to_string(sh->Stage), sh->Name);
1064          _mesa_log("%s\n", sh->Source);
1065          _mesa_log("Info Log:\n%s\n", sh->InfoLog);
1066       }
1067
1068       if (ctx->_Shader->Flags & GLSL_REPORT_ERRORS) {
1069          _mesa_debug(ctx, "Error compiling shader %u:\n%s\n",
1070                      sh->Name, sh->InfoLog);
1071       }
1072    }
1073 }
1074
1075
1076 /**
1077  * Link a program's shaders.
1078  */
1079 void
1080 _mesa_link_program(struct gl_context *ctx, struct gl_shader_program *shProg)
1081 {
1082    if (!shProg)
1083       return;
1084
1085    /* From the ARB_transform_feedback2 specification:
1086     * "The error INVALID_OPERATION is generated by LinkProgram if <program> is
1087     *  the name of a program being used by one or more transform feedback
1088     *  objects, even if the objects are not currently bound or are paused."
1089     */
1090    if (_mesa_transform_feedback_is_using_program(ctx, shProg)) {
1091       _mesa_error(ctx, GL_INVALID_OPERATION,
1092                   "glLinkProgram(transform feedback is using the program)");
1093       return;
1094    }
1095
1096    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
1097
1098    _mesa_glsl_link_shader(ctx, shProg);
1099
1100    /* Capture .shader_test files. */
1101    const char *capture_path = _mesa_get_shader_capture_path();
1102    if (shProg->Name != 0 && shProg->Name != ~0 && capture_path != NULL) {
1103       FILE *file;
1104       char filename[PATH_MAX];
1105
1106       _mesa_snprintf(filename, sizeof(filename), "%s/%u.shader_test",
1107                      capture_path, shProg->Name);
1108
1109       file = fopen(filename, "w");
1110       if (file) {
1111          fprintf(file, "[require]\nGLSL%s >= %u.%02u\n",
1112                  shProg->IsES ? " ES" : "",
1113                  shProg->Version / 100, shProg->Version % 100);
1114          if (shProg->SeparateShader)
1115             fprintf(file, "GL_ARB_separate_shader_objects\nSSO ENABLED\n");
1116          fprintf(file, "\n");
1117
1118          for (unsigned i = 0; i < shProg->NumShaders; i++) {
1119             fprintf(file, "[%s shader]\n%s\n",
1120                     _mesa_shader_stage_to_string(shProg->Shaders[i]->Stage),
1121                     shProg->Shaders[i]->Source);
1122          }
1123          fclose(file);
1124       } else {
1125          _mesa_warning(ctx, "Failed to open %s", filename);
1126       }
1127    }
1128
1129    if (shProg->LinkStatus == GL_FALSE &&
1130        (ctx->_Shader->Flags & GLSL_REPORT_ERRORS)) {
1131       _mesa_debug(ctx, "Error linking program %u:\n%s\n",
1132                   shProg->Name, shProg->InfoLog);
1133    }
1134
1135    /* debug code */
1136    if (0) {
1137       GLuint i;
1138
1139       printf("Link %u shaders in program %u: %s\n",
1140                    shProg->NumShaders, shProg->Name,
1141                    shProg->LinkStatus ? "Success" : "Failed");
1142
1143       for (i = 0; i < shProg->NumShaders; i++) {
1144          printf(" shader %u, stage %u\n",
1145                       shProg->Shaders[i]->Name,
1146                       shProg->Shaders[i]->Stage);
1147       }
1148    }
1149 }
1150
1151
1152 /**
1153  * Print basic shader info (for debug).
1154  */
1155 static void
1156 print_shader_info(const struct gl_shader_program *shProg)
1157 {
1158    GLuint i;
1159
1160    printf("Mesa: glUseProgram(%u)\n", shProg->Name);
1161    for (i = 0; i < shProg->NumShaders; i++) {
1162       printf("  %s shader %u, checksum %u\n",
1163              _mesa_shader_stage_to_string(shProg->Shaders[i]->Stage),
1164              shProg->Shaders[i]->Name,
1165              shProg->Shaders[i]->SourceChecksum);
1166    }
1167    if (shProg->_LinkedShaders[MESA_SHADER_VERTEX])
1168       printf("  vert prog %u\n",
1169              shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program->Id);
1170    if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT])
1171       printf("  frag prog %u\n",
1172              shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program->Id);
1173    if (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY])
1174       printf("  geom prog %u\n",
1175              shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program->Id);
1176    if (shProg->_LinkedShaders[MESA_SHADER_TESS_CTRL])
1177       printf("  tesc prog %u\n",
1178              shProg->_LinkedShaders[MESA_SHADER_TESS_CTRL]->Program->Id);
1179    if (shProg->_LinkedShaders[MESA_SHADER_TESS_EVAL])
1180       printf("  tese prog %u\n",
1181              shProg->_LinkedShaders[MESA_SHADER_TESS_EVAL]->Program->Id);
1182 }
1183
1184
1185 /**
1186  * Use the named shader program for subsequent glUniform calls
1187  */
1188 void
1189 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
1190                      const char *caller)
1191 {
1192    if ((shProg != NULL) && !shProg->LinkStatus) {
1193       _mesa_error(ctx, GL_INVALID_OPERATION,
1194                   "%s(program %u not linked)", caller, shProg->Name);
1195       return;
1196    }
1197
1198    if (ctx->Shader.ActiveProgram != shProg) {
1199       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
1200    }
1201 }
1202
1203
1204 static void
1205 use_shader_program(struct gl_context *ctx, gl_shader_stage stage,
1206                    struct gl_shader_program *shProg,
1207                    struct gl_pipeline_object *shTarget)
1208 {
1209    struct gl_shader_program **target;
1210
1211    target = &shTarget->CurrentProgram[stage];
1212    if ((shProg != NULL) && (shProg->_LinkedShaders[stage] == NULL))
1213       shProg = NULL;
1214
1215    if (shProg)
1216       _mesa_shader_program_init_subroutine_defaults(ctx, shProg);
1217
1218    if (*target != shProg) {
1219       /* Program is current, flush it */
1220       if (shTarget == ctx->_Shader) {
1221          FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
1222       }
1223
1224       /* If the shader is also bound as the current rendering shader, unbind
1225        * it from that binding point as well.  This ensures that the correct
1226        * semantics of glDeleteProgram are maintained.
1227        */
1228       switch (stage) {
1229       case MESA_SHADER_VERTEX:
1230       case MESA_SHADER_TESS_CTRL:
1231       case MESA_SHADER_TESS_EVAL:
1232       case MESA_SHADER_GEOMETRY:
1233       case MESA_SHADER_COMPUTE:
1234          /* Empty for now. */
1235          break;
1236       case MESA_SHADER_FRAGMENT:
1237          if (*target == ctx->_Shader->_CurrentFragmentProgram) {
1238             _mesa_reference_shader_program(ctx,
1239                                            &ctx->_Shader->_CurrentFragmentProgram,
1240                                            NULL);
1241          }
1242          break;
1243       }
1244
1245       _mesa_reference_shader_program(ctx, target, shProg);
1246       return;
1247    }
1248 }
1249
1250
1251 /**
1252  * Use the named shader program for subsequent rendering.
1253  */
1254 void
1255 _mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
1256 {
1257    int i;
1258    for (i = 0; i < MESA_SHADER_STAGES; i++)
1259       use_shader_program(ctx, i, shProg, &ctx->Shader);
1260    _mesa_active_program(ctx, shProg, "glUseProgram");
1261 }
1262
1263
1264 /**
1265  * Do validation of the given shader program.
1266  * \param errMsg  returns error message if validation fails.
1267  * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1268  */
1269 static GLboolean
1270 validate_shader_program(const struct gl_shader_program *shProg,
1271                         char *errMsg)
1272 {
1273    if (!shProg->LinkStatus) {
1274       return GL_FALSE;
1275    }
1276
1277    /* From the GL spec, a program is invalid if any of these are true:
1278
1279      any two active samplers in the current program object are of
1280      different types, but refer to the same texture image unit,
1281
1282      any active sampler in the current program object refers to a texture
1283      image unit where fixed-function fragment processing accesses a
1284      texture target that does not match the sampler type, or
1285
1286      the sum of the number of active samplers in the program and the
1287      number of texture image units enabled for fixed-function fragment
1288      processing exceeds the combined limit on the total number of texture
1289      image units allowed.
1290    */
1291
1292    /*
1293     * Check: any two active samplers in the current program object are of
1294     * different types, but refer to the same texture image unit,
1295     */
1296    if (!_mesa_sampler_uniforms_are_valid(shProg, errMsg, 100))
1297       return GL_FALSE;
1298
1299    return GL_TRUE;
1300 }
1301
1302
1303 /**
1304  * Called via glValidateProgram()
1305  */
1306 static void
1307 validate_program(struct gl_context *ctx, GLuint program)
1308 {
1309    struct gl_shader_program *shProg;
1310    char errMsg[100] = "";
1311
1312    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1313    if (!shProg) {
1314       return;
1315    }
1316
1317    shProg->Validated = validate_shader_program(shProg, errMsg);
1318    if (!shProg->Validated) {
1319       /* update info log */
1320       if (shProg->InfoLog) {
1321          ralloc_free(shProg->InfoLog);
1322       }
1323       shProg->InfoLog = ralloc_strdup(shProg, errMsg);
1324    }
1325 }
1326
1327
1328
1329 void GLAPIENTRY
1330 _mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
1331 {
1332    GET_CURRENT_CONTEXT(ctx);
1333    attach_shader(ctx, program, shader);
1334 }
1335
1336
1337 void GLAPIENTRY
1338 _mesa_AttachShader(GLuint program, GLuint shader)
1339 {
1340    GET_CURRENT_CONTEXT(ctx);
1341    attach_shader(ctx, program, shader);
1342 }
1343
1344
1345 void GLAPIENTRY
1346 _mesa_CompileShader(GLuint shaderObj)
1347 {
1348    GET_CURRENT_CONTEXT(ctx);
1349    if (MESA_VERBOSE & VERBOSE_API)
1350       _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
1351    _mesa_compile_shader(ctx, _mesa_lookup_shader_err(ctx, shaderObj,
1352                                                      "glCompileShader"));
1353 }
1354
1355
1356 GLuint GLAPIENTRY
1357 _mesa_CreateShader(GLenum type)
1358 {
1359    GET_CURRENT_CONTEXT(ctx);
1360    if (MESA_VERBOSE & VERBOSE_API)
1361       _mesa_debug(ctx, "glCreateShader %s\n", _mesa_enum_to_string(type));
1362    return create_shader(ctx, type);
1363 }
1364
1365
1366 GLhandleARB GLAPIENTRY
1367 _mesa_CreateShaderObjectARB(GLenum type)
1368 {
1369    GET_CURRENT_CONTEXT(ctx);
1370    return create_shader(ctx, type);
1371 }
1372
1373
1374 GLuint GLAPIENTRY
1375 _mesa_CreateProgram(void)
1376 {
1377    GET_CURRENT_CONTEXT(ctx);
1378    if (MESA_VERBOSE & VERBOSE_API)
1379       _mesa_debug(ctx, "glCreateProgram\n");
1380    return create_shader_program(ctx);
1381 }
1382
1383
1384 GLhandleARB GLAPIENTRY
1385 _mesa_CreateProgramObjectARB(void)
1386 {
1387    GET_CURRENT_CONTEXT(ctx);
1388    return create_shader_program(ctx);
1389 }
1390
1391
1392 void GLAPIENTRY
1393 _mesa_DeleteObjectARB(GLhandleARB obj)
1394 {
1395    if (MESA_VERBOSE & VERBOSE_API) {
1396       GET_CURRENT_CONTEXT(ctx);
1397       _mesa_debug(ctx, "glDeleteObjectARB(%lu)\n", (unsigned long)obj);
1398    }
1399
1400    if (obj) {
1401       GET_CURRENT_CONTEXT(ctx);
1402       FLUSH_VERTICES(ctx, 0);
1403       if (is_program(ctx, obj)) {
1404          delete_shader_program(ctx, obj);
1405       }
1406       else if (is_shader(ctx, obj)) {
1407          delete_shader(ctx, obj);
1408       }
1409       else {
1410          /* error? */
1411       }
1412    }
1413 }
1414
1415
1416 void GLAPIENTRY
1417 _mesa_DeleteProgram(GLuint name)
1418 {
1419    if (name) {
1420       GET_CURRENT_CONTEXT(ctx);
1421       FLUSH_VERTICES(ctx, 0);
1422       delete_shader_program(ctx, name);
1423    }
1424 }
1425
1426
1427 void GLAPIENTRY
1428 _mesa_DeleteShader(GLuint name)
1429 {
1430    if (name) {
1431       GET_CURRENT_CONTEXT(ctx);
1432       FLUSH_VERTICES(ctx, 0);
1433       delete_shader(ctx, name);
1434    }
1435 }
1436
1437
1438 void GLAPIENTRY
1439 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
1440 {
1441    GET_CURRENT_CONTEXT(ctx);
1442    detach_shader(ctx, program, shader);
1443 }
1444
1445
1446 void GLAPIENTRY
1447 _mesa_DetachShader(GLuint program, GLuint shader)
1448 {
1449    GET_CURRENT_CONTEXT(ctx);
1450    detach_shader(ctx, program, shader);
1451 }
1452
1453
1454 void GLAPIENTRY
1455 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
1456                             GLsizei * count, GLhandleARB * obj)
1457 {
1458    GET_CURRENT_CONTEXT(ctx);
1459    get_attached_shaders(ctx, container, maxCount, count, obj);
1460 }
1461
1462
1463 void GLAPIENTRY
1464 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
1465                          GLsizei *count, GLuint *obj)
1466 {
1467    GET_CURRENT_CONTEXT(ctx);
1468    get_attached_shaders(ctx, program, maxCount, count, obj);
1469 }
1470
1471
1472 void GLAPIENTRY
1473 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
1474                     GLcharARB * infoLog)
1475 {
1476    GET_CURRENT_CONTEXT(ctx);
1477    if (is_program(ctx, object)) {
1478       get_program_info_log(ctx, object, maxLength, length, infoLog);
1479    }
1480    else if (is_shader(ctx, object)) {
1481       get_shader_info_log(ctx, object, maxLength, length, infoLog);
1482    }
1483    else {
1484       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1485    }
1486 }
1487
1488
1489 void GLAPIENTRY
1490 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
1491 {
1492    GET_CURRENT_CONTEXT(ctx);
1493    /* Implement in terms of GetProgramiv, GetShaderiv */
1494    if (is_program(ctx, object)) {
1495       if (pname == GL_OBJECT_TYPE_ARB) {
1496          *params = GL_PROGRAM_OBJECT_ARB;
1497       }
1498       else {
1499          get_programiv(ctx, object, pname, params);
1500       }
1501    }
1502    else if (is_shader(ctx, object)) {
1503       if (pname == GL_OBJECT_TYPE_ARB) {
1504          *params = GL_SHADER_OBJECT_ARB;
1505       }
1506       else {
1507          get_shaderiv(ctx, object, pname, params);
1508       }
1509    }
1510    else {
1511       _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1512    }
1513 }
1514
1515
1516 void GLAPIENTRY
1517 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
1518                               GLfloat *params)
1519 {
1520    GLint iparams[1] = {0};  /* XXX is one element enough? */
1521    _mesa_GetObjectParameterivARB(object, pname, iparams);
1522    params[0] = (GLfloat) iparams[0];
1523 }
1524
1525
1526 void GLAPIENTRY
1527 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
1528 {
1529    GET_CURRENT_CONTEXT(ctx);
1530    get_programiv(ctx, program, pname, params);
1531 }
1532
1533
1534 void GLAPIENTRY
1535 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
1536 {
1537    GET_CURRENT_CONTEXT(ctx);
1538    get_shaderiv(ctx, shader, pname, params);
1539 }
1540
1541
1542 void GLAPIENTRY
1543 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
1544                         GLsizei *length, GLchar *infoLog)
1545 {
1546    GET_CURRENT_CONTEXT(ctx);
1547    get_program_info_log(ctx, program, bufSize, length, infoLog);
1548 }
1549
1550
1551 void GLAPIENTRY
1552 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
1553                        GLsizei *length, GLchar *infoLog)
1554 {
1555    GET_CURRENT_CONTEXT(ctx);
1556    get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1557 }
1558
1559
1560 void GLAPIENTRY
1561 _mesa_GetShaderSource(GLuint shader, GLsizei maxLength,
1562                       GLsizei *length, GLchar *sourceOut)
1563 {
1564    GET_CURRENT_CONTEXT(ctx);
1565    get_shader_source(ctx, shader, maxLength, length, sourceOut);
1566 }
1567
1568
1569 GLhandleARB GLAPIENTRY
1570 _mesa_GetHandleARB(GLenum pname)
1571 {
1572    GET_CURRENT_CONTEXT(ctx);
1573    return get_handle(ctx, pname);
1574 }
1575
1576
1577 GLboolean GLAPIENTRY
1578 _mesa_IsProgram(GLuint name)
1579 {
1580    GET_CURRENT_CONTEXT(ctx);
1581    return is_program(ctx, name);
1582 }
1583
1584
1585 GLboolean GLAPIENTRY
1586 _mesa_IsShader(GLuint name)
1587 {
1588    GET_CURRENT_CONTEXT(ctx);
1589    return is_shader(ctx, name);
1590 }
1591
1592
1593 void GLAPIENTRY
1594 _mesa_LinkProgram(GLuint programObj)
1595 {
1596    GET_CURRENT_CONTEXT(ctx);
1597    if (MESA_VERBOSE & VERBOSE_API)
1598       _mesa_debug(ctx, "glLinkProgram %u\n", programObj);
1599    _mesa_link_program(ctx, _mesa_lookup_shader_program_err(ctx, programObj,
1600                                                            "glLinkProgram"));
1601 }
1602
1603 #if defined(HAVE_SHA1)
1604 /**
1605  * Generate a SHA-1 hash value string for given source string.
1606  */
1607 static void
1608 generate_sha1(const char *source, char sha_str[64])
1609 {
1610    unsigned char sha[20];
1611    _mesa_sha1_compute(source, strlen(source), sha);
1612    _mesa_sha1_format(sha_str, sha);
1613 }
1614
1615 /**
1616  * Construct a full path for shader replacement functionality using
1617  * following format:
1618  *
1619  * <path>/<stage prefix>_<CHECKSUM>.glsl
1620  */
1621 static void
1622 construct_name(const gl_shader_stage stage, const char *source,
1623                const char *path, char *name, unsigned length)
1624 {
1625    char sha[64];
1626    static const char *types[] = {
1627       "VS", "TC", "TE", "GS", "FS", "CS",
1628    };
1629
1630    generate_sha1(source, sha);
1631    _mesa_snprintf(name, length, "%s/%s_%s.glsl", path, types[stage],
1632                   sha);
1633 }
1634
1635 /**
1636  * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1637  */
1638 static void
1639 dump_shader(const gl_shader_stage stage, const char *source)
1640 {
1641    char name[PATH_MAX];
1642    static bool path_exists = true;
1643    char *dump_path;
1644    FILE *f;
1645
1646    if (!path_exists)
1647       return;
1648
1649    dump_path = getenv("MESA_SHADER_DUMP_PATH");
1650    if (!dump_path) {
1651       path_exists = false;
1652       return;
1653    }
1654
1655    construct_name(stage, source, dump_path, name, PATH_MAX);
1656
1657    f = fopen(name, "w");
1658    if (f) {
1659       fputs(source, f);
1660       fclose(f);
1661    } else {
1662       GET_CURRENT_CONTEXT(ctx);
1663       _mesa_warning(ctx, "could not open %s for dumping shader (%s)", name,
1664                     strerror(errno));
1665    }
1666 }
1667
1668 /**
1669  * Read shader source code from a file.
1670  * Useful for debugging to override an app's shader.
1671  */
1672 static GLcharARB *
1673 read_shader(const gl_shader_stage stage, const char *source)
1674 {
1675    char name[PATH_MAX];
1676    char *read_path;
1677    static bool path_exists = true;
1678    int len, shader_size = 0;
1679    GLcharARB *buffer;
1680    FILE *f;
1681
1682    if (!path_exists)
1683       return NULL;
1684
1685    read_path = getenv("MESA_SHADER_READ_PATH");
1686    if (!read_path) {
1687       path_exists = false;
1688       return NULL;
1689    }
1690
1691    construct_name(stage, source, read_path, name, PATH_MAX);
1692
1693    f = fopen(name, "r");
1694    if (!f)
1695       return NULL;
1696
1697    /* allocate enough room for the entire shader */
1698    fseek(f, 0, SEEK_END);
1699    shader_size = ftell(f);
1700    rewind(f);
1701    assert(shader_size);
1702
1703    /* add one for terminating zero */
1704    shader_size++;
1705
1706    buffer = malloc(shader_size);
1707    assert(buffer);
1708
1709    len = fread(buffer, 1, shader_size, f);
1710    buffer[len] = 0;
1711
1712    fclose(f);
1713
1714    return buffer;
1715 }
1716 #endif /* HAVE_SHA1 */
1717
1718 /**
1719  * Called via glShaderSource() and glShaderSourceARB() API functions.
1720  * Basically, concatenate the source code strings into one long string
1721  * and pass it to _mesa_shader_source().
1722  */
1723 void GLAPIENTRY
1724 _mesa_ShaderSource(GLuint shaderObj, GLsizei count,
1725                    const GLchar * const * string, const GLint * length)
1726 {
1727    GET_CURRENT_CONTEXT(ctx);
1728    GLint *offsets;
1729    GLsizei i, totalLength;
1730    GLcharARB *source;
1731    struct gl_shader *sh;
1732
1733 #if defined(HAVE_SHA1)
1734    GLcharARB *replacement;
1735 #endif /* HAVE_SHA1 */
1736
1737    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glShaderSourceARB");
1738    if (!sh)
1739       return;
1740
1741    if (string == NULL) {
1742       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1743       return;
1744    }
1745
1746    /*
1747     * This array holds offsets of where the appropriate string ends, thus the
1748     * last element will be set to the total length of the source code.
1749     */
1750    offsets = malloc(count * sizeof(GLint));
1751    if (offsets == NULL) {
1752       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1753       return;
1754    }
1755
1756    for (i = 0; i < count; i++) {
1757       if (string[i] == NULL) {
1758          free((GLvoid *) offsets);
1759          _mesa_error(ctx, GL_INVALID_OPERATION,
1760                      "glShaderSourceARB(null string)");
1761          return;
1762       }
1763       if (length == NULL || length[i] < 0)
1764          offsets[i] = strlen(string[i]);
1765       else
1766          offsets[i] = length[i];
1767       /* accumulate string lengths */
1768       if (i > 0)
1769          offsets[i] += offsets[i - 1];
1770    }
1771
1772    /* Total length of source string is sum off all strings plus two.
1773     * One extra byte for terminating zero, another extra byte to silence
1774     * valgrind warnings in the parser/grammer code.
1775     */
1776    totalLength = offsets[count - 1] + 2;
1777    source = malloc(totalLength * sizeof(GLcharARB));
1778    if (source == NULL) {
1779       free((GLvoid *) offsets);
1780       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1781       return;
1782    }
1783
1784    for (i = 0; i < count; i++) {
1785       GLint start = (i > 0) ? offsets[i - 1] : 0;
1786       memcpy(source + start, string[i],
1787              (offsets[i] - start) * sizeof(GLcharARB));
1788    }
1789    source[totalLength - 1] = '\0';
1790    source[totalLength - 2] = '\0';
1791
1792 #if defined(HAVE_SHA1)
1793    /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
1794     * if corresponding entry found from MESA_SHADER_READ_PATH.
1795     */
1796    dump_shader(sh->Stage, source);
1797
1798    replacement = read_shader(sh->Stage, source);
1799    if (replacement) {
1800       free(source);
1801       source = replacement;
1802    }
1803 #endif /* HAVE_SHA1 */
1804
1805    shader_source(sh, source);
1806
1807    free(offsets);
1808 }
1809
1810
1811 void GLAPIENTRY
1812 _mesa_UseProgram(GLuint program)
1813 {
1814    GET_CURRENT_CONTEXT(ctx);
1815    struct gl_shader_program *shProg;
1816
1817    if (MESA_VERBOSE & VERBOSE_API)
1818       _mesa_debug(ctx, "glUseProgram %u\n", program);
1819
1820    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1821       _mesa_error(ctx, GL_INVALID_OPERATION,
1822                   "glUseProgram(transform feedback active)");
1823       return;
1824    }
1825
1826    if (program) {
1827       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1828       if (!shProg) {
1829          return;
1830       }
1831       if (!shProg->LinkStatus) {
1832          _mesa_error(ctx, GL_INVALID_OPERATION,
1833                      "glUseProgram(program %u not linked)", program);
1834          return;
1835       }
1836
1837       /* debug code */
1838       if (ctx->_Shader->Flags & GLSL_USE_PROG) {
1839          print_shader_info(shProg);
1840       }
1841    }
1842    else {
1843       shProg = NULL;
1844    }
1845
1846    /* The ARB_separate_shader_object spec says:
1847     *
1848     *     "The executable code for an individual shader stage is taken from
1849     *     the current program for that stage.  If there is a current program
1850     *     object established by UseProgram, that program is considered current
1851     *     for all stages.  Otherwise, if there is a bound program pipeline
1852     *     object (section 2.14.PPO), the program bound to the appropriate
1853     *     stage of the pipeline object is considered current."
1854     */
1855    if (program) {
1856       /* Attach shader state to the binding point */
1857       _mesa_reference_pipeline_object(ctx, &ctx->_Shader, &ctx->Shader);
1858       /* Update the program */
1859       _mesa_use_program(ctx, shProg);
1860    } else {
1861       /* Must be done first: detach the progam */
1862       _mesa_use_program(ctx, shProg);
1863       /* Unattach shader_state binding point */
1864       _mesa_reference_pipeline_object(ctx, &ctx->_Shader, ctx->Pipeline.Default);
1865       /* If a pipeline was bound, rebind it */
1866       if (ctx->Pipeline.Current) {
1867          _mesa_BindProgramPipeline(ctx->Pipeline.Current->Name);
1868       }
1869    }
1870 }
1871
1872
1873 void GLAPIENTRY
1874 _mesa_ValidateProgram(GLuint program)
1875 {
1876    GET_CURRENT_CONTEXT(ctx);
1877    validate_program(ctx, program);
1878 }
1879
1880
1881 /**
1882  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1883  */
1884 void GLAPIENTRY
1885 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1886                                GLint* range, GLint* precision)
1887 {
1888    const struct gl_program_constants *limits;
1889    const struct gl_precision *p;
1890    GET_CURRENT_CONTEXT(ctx);
1891
1892    switch (shadertype) {
1893    case GL_VERTEX_SHADER:
1894       limits = &ctx->Const.Program[MESA_SHADER_VERTEX];
1895       break;
1896    case GL_FRAGMENT_SHADER:
1897       limits = &ctx->Const.Program[MESA_SHADER_FRAGMENT];
1898       break;
1899    default:
1900       _mesa_error(ctx, GL_INVALID_ENUM,
1901                   "glGetShaderPrecisionFormat(shadertype)");
1902       return;
1903    }
1904
1905    switch (precisiontype) {
1906    case GL_LOW_FLOAT:
1907       p = &limits->LowFloat;
1908       break;
1909    case GL_MEDIUM_FLOAT:
1910       p = &limits->MediumFloat;
1911       break;
1912    case GL_HIGH_FLOAT:
1913       p = &limits->HighFloat;
1914       break;
1915    case GL_LOW_INT:
1916       p = &limits->LowInt;
1917       break;
1918    case GL_MEDIUM_INT:
1919       p = &limits->MediumInt;
1920       break;
1921    case GL_HIGH_INT:
1922       p = &limits->HighInt;
1923       break;
1924    default:
1925       _mesa_error(ctx, GL_INVALID_ENUM,
1926                   "glGetShaderPrecisionFormat(precisiontype)");
1927       return;
1928    }
1929
1930    range[0] = p->RangeMin;
1931    range[1] = p->RangeMax;
1932    precision[0] = p->Precision;
1933 }
1934
1935
1936 /**
1937  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1938  */
1939 void GLAPIENTRY
1940 _mesa_ReleaseShaderCompiler(void)
1941 {
1942    _mesa_destroy_shader_compiler_caches();
1943 }
1944
1945
1946 /**
1947  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1948  */
1949 void GLAPIENTRY
1950 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1951                    const void* binary, GLint length)
1952 {
1953    GET_CURRENT_CONTEXT(ctx);
1954    (void) shaders;
1955    (void) binaryformat;
1956    (void) binary;
1957
1958    /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
1959     * page 88 of the OpenGL 4.5 specs state:
1960     *
1961     *     "An INVALID_VALUE error is generated if count or length is negative.
1962     *      An INVALID_ENUM error is generated if binaryformat is not a supported
1963     *      format returned in SHADER_BINARY_FORMATS."
1964     */
1965    if (n < 0 || length < 0) {
1966       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderBinary(count or length < 0)");
1967       return;
1968    }
1969
1970    _mesa_error(ctx, GL_INVALID_ENUM, "glShaderBinary(format)");
1971 }
1972
1973
1974 void GLAPIENTRY
1975 _mesa_GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
1976                        GLenum *binaryFormat, GLvoid *binary)
1977 {
1978    struct gl_shader_program *shProg;
1979    GLsizei length_dummy;
1980    GET_CURRENT_CONTEXT(ctx);
1981
1982    if (bufSize < 0){
1983       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramBinary(bufSize < 0)");
1984       return;
1985    }
1986
1987    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetProgramBinary");
1988    if (!shProg)
1989       return;
1990
1991    /* The ARB_get_program_binary spec says:
1992     *
1993     *     "If <length> is NULL, then no length is returned."
1994     *
1995     * Ensure that length always points to valid storage to avoid multiple NULL
1996     * pointer checks below.
1997     */
1998    if (length == NULL)
1999       length = &length_dummy;
2000
2001
2002    /* The ARB_get_program_binary spec says:
2003     *
2004     *     "When a program object's LINK_STATUS is FALSE, its program binary
2005     *     length is zero, and a call to GetProgramBinary will generate an
2006     *     INVALID_OPERATION error.
2007     */
2008    if (!shProg->LinkStatus) {
2009       _mesa_error(ctx, GL_INVALID_OPERATION,
2010                   "glGetProgramBinary(program %u not linked)",
2011                   shProg->Name);
2012       *length = 0;
2013       return;
2014    }
2015
2016    *length = 0;
2017    _mesa_error(ctx, GL_INVALID_OPERATION,
2018                "glGetProgramBinary(driver supports zero binary formats)");
2019
2020    (void) binaryFormat;
2021    (void) binary;
2022 }
2023
2024 void GLAPIENTRY
2025 _mesa_ProgramBinary(GLuint program, GLenum binaryFormat,
2026                     const GLvoid *binary, GLsizei length)
2027 {
2028    struct gl_shader_program *shProg;
2029    GET_CURRENT_CONTEXT(ctx);
2030
2031    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramBinary");
2032    if (!shProg)
2033       return;
2034
2035    (void) binaryFormat;
2036    (void) binary;
2037
2038    /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
2039     *
2040     *     "If a negative number is provided where an argument of type sizei or
2041     *     sizeiptr is specified, an INVALID_VALUE error is generated."
2042     */
2043    if (length < 0) {
2044       _mesa_error(ctx, GL_INVALID_VALUE, "glProgramBinary(length < 0)");
2045       return;
2046    }
2047
2048    /* The ARB_get_program_binary spec says:
2049     *
2050     *     "<binaryFormat> and <binary> must be those returned by a previous
2051     *     call to GetProgramBinary, and <length> must be the length of the
2052     *     program binary as returned by GetProgramBinary or GetProgramiv with
2053     *     <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
2054     *     setting the LINK_STATUS of <program> to FALSE, if these conditions
2055     *     are not met."
2056     *
2057     * Since any value of binaryFormat passed "is not one of those specified as
2058     * allowable for [this] command, an INVALID_ENUM error is generated."
2059     */
2060    shProg->LinkStatus = GL_FALSE;
2061    _mesa_error(ctx, GL_INVALID_ENUM, "glProgramBinary");
2062 }
2063
2064
2065 void GLAPIENTRY
2066 _mesa_ProgramParameteri(GLuint program, GLenum pname, GLint value)
2067 {
2068    struct gl_shader_program *shProg;
2069    GET_CURRENT_CONTEXT(ctx);
2070
2071    shProg = _mesa_lookup_shader_program_err(ctx, program,
2072                                             "glProgramParameteri");
2073    if (!shProg)
2074       return;
2075
2076    switch (pname) {
2077    case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
2078       /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
2079        * is part of OpenGL ES 3.0.  For the ES2 case, this function shouldn't
2080        * even be in the dispatch table, so we shouldn't need to expclicitly
2081        * check here.
2082        *
2083        * On desktop, we ignore the 3.0+ requirement because it is silly.
2084        */
2085
2086       /* The ARB_get_program_binary extension spec says:
2087        *
2088        *     "An INVALID_VALUE error is generated if the <value> argument to
2089        *     ProgramParameteri is not TRUE or FALSE."
2090        */
2091       if (value != GL_TRUE && value != GL_FALSE) {
2092          goto invalid_value;
2093       }
2094
2095       /* No need to notify the driver.  Any changes will actually take effect
2096        * the next time the shader is linked.
2097        *
2098        * The ARB_get_program_binary extension spec says:
2099        *
2100        *     "To indicate that a program binary is likely to be retrieved,
2101        *     ProgramParameteri should be called with <pname>
2102        *     PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2103        *     will not be in effect until the next time LinkProgram or
2104        *     ProgramBinary has been called successfully."
2105        *
2106        * The resloution of issue 9 in the extension spec also says:
2107        *
2108        *     "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2109        *     to indicate to the GL implementation that this program will
2110        *     likely be saved with GetProgramBinary at some point. This will
2111        *     give the GL implementation the opportunity to track any state
2112        *     changes made to the program before being saved such that when it
2113        *     is loaded again a recompile can be avoided."
2114        */
2115       shProg->BinaryRetreivableHint = value;
2116       return;
2117
2118    case GL_PROGRAM_SEPARABLE:
2119       /* Spec imply that the behavior is the same as ARB_get_program_binary
2120        * Chapter 7.3 Program Objects
2121        */
2122       if (value != GL_TRUE && value != GL_FALSE) {
2123          goto invalid_value;
2124       }
2125       shProg->SeparateShader = value;
2126       return;
2127
2128    default:
2129       _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteri(pname=%s)",
2130                   _mesa_enum_to_string(pname));
2131       return;
2132    }
2133
2134 invalid_value:
2135    _mesa_error(ctx, GL_INVALID_VALUE,
2136                "glProgramParameteri(pname=%s, value=%d): "
2137                "value must be 0 or 1.",
2138                _mesa_enum_to_string(pname),
2139                value);
2140 }
2141
2142
2143 void
2144 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
2145                          struct gl_shader_program *shProg,
2146                          struct gl_pipeline_object *shTarget)
2147 {
2148    gl_shader_stage stage = _mesa_shader_enum_to_shader_stage(type);
2149    use_shader_program(ctx, stage, shProg, shTarget);
2150 }
2151
2152
2153 /**
2154  * Copy program-specific data generated by linking from the gl_shader_program
2155  * object to the gl_program object referred to by the gl_linked_shader.
2156  *
2157  * This function expects _mesa_reference_program() to have been previously
2158  * called setting the gl_linked_shaders program reference.
2159  */
2160 void
2161 _mesa_copy_linked_program_data(const struct gl_shader_program *src,
2162                                struct gl_linked_shader *dst_sh)
2163 {
2164    assert(dst_sh->Program);
2165
2166    struct gl_program *dst = dst_sh->Program;
2167
2168    switch (dst_sh->Stage) {
2169    case MESA_SHADER_VERTEX:
2170       dst->ClipDistanceArraySize = src->Vert.ClipDistanceArraySize;
2171       dst->CullDistanceArraySize = src->Vert.CullDistanceArraySize;
2172       break;
2173    case MESA_SHADER_TESS_CTRL: {
2174       dst->info.tcs.vertices_out = dst_sh->info.TessCtrl.VerticesOut;
2175       break;
2176    }
2177    case MESA_SHADER_TESS_EVAL: {
2178       dst->info.tes.primitive_mode = dst_sh->info.TessEval.PrimitiveMode;
2179       dst->info.tes.spacing = dst_sh->info.TessEval.Spacing;
2180       dst->info.tes.vertex_order = dst_sh->info.TessEval.VertexOrder;
2181       dst->info.tes.point_mode = dst_sh->info.TessEval.PointMode;
2182       dst->ClipDistanceArraySize = src->TessEval.ClipDistanceArraySize;
2183       dst->CullDistanceArraySize = src->TessEval.CullDistanceArraySize;
2184       break;
2185    }
2186    case MESA_SHADER_GEOMETRY: {
2187       dst->info.gs.vertices_in = src->Geom.VerticesIn;
2188       dst->info.gs.vertices_out = dst_sh->info.Geom.VerticesOut;
2189       dst->info.gs.invocations = dst_sh->info.Geom.Invocations;
2190       dst->info.gs.input_primitive = dst_sh->info.Geom.InputType;
2191       dst->info.gs.output_primitive = dst_sh->info.Geom.OutputType;
2192       dst->ClipDistanceArraySize = src->Geom.ClipDistanceArraySize;
2193       dst->CullDistanceArraySize = src->Geom.CullDistanceArraySize;
2194       dst->info.gs.uses_end_primitive = src->Geom.UsesEndPrimitive;
2195       dst->info.gs.uses_streams = src->Geom.UsesStreams;
2196       break;
2197    }
2198    case MESA_SHADER_FRAGMENT: {
2199       dst->info.fs.depth_layout = src->FragDepthLayout;
2200       dst->info.fs.early_fragment_tests = dst_sh->info.EarlyFragmentTests;
2201       break;
2202    }
2203    case MESA_SHADER_COMPUTE: {
2204       for (int i = 0; i < 3; i++)
2205          dst->info.cs.local_size[i] = src->Comp.LocalSize[i];
2206       dst->info.cs.shared_size = src->Comp.SharedSize;
2207       break;
2208    }
2209    default:
2210       break;
2211    }
2212
2213    copy_shader_info(src, dst_sh);
2214 }
2215
2216 /**
2217  * ARB_separate_shader_objects: Compile & Link Program
2218  */
2219 GLuint GLAPIENTRY
2220 _mesa_CreateShaderProgramv(GLenum type, GLsizei count,
2221                            const GLchar* const *strings)
2222 {
2223    GET_CURRENT_CONTEXT(ctx);
2224
2225    const GLuint shader = create_shader(ctx, type);
2226    GLuint program = 0;
2227
2228    /*
2229     * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2230     * GL_INVALID_VALUE should be generated if count < 0
2231     */
2232    if (count < 0) {
2233       _mesa_error(ctx, GL_INVALID_VALUE, "glCreateShaderProgram (count < 0)");
2234       return program;
2235    }
2236
2237    if (shader) {
2238       struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
2239
2240       _mesa_ShaderSource(shader, count, strings, NULL);
2241       _mesa_compile_shader(ctx, sh);
2242
2243       program = create_shader_program(ctx);
2244       if (program) {
2245          struct gl_shader_program *shProg;
2246          GLint compiled = GL_FALSE;
2247
2248          shProg = _mesa_lookup_shader_program(ctx, program);
2249
2250          shProg->SeparateShader = GL_TRUE;
2251
2252          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
2253          if (compiled) {
2254             attach_shader(ctx, program, shader);
2255             _mesa_link_program(ctx, shProg);
2256             detach_shader(ctx, program, shader);
2257
2258 #if 0
2259             /* Possibly... */
2260             if (active-user-defined-varyings-in-linked-program) {
2261                append-error-to-info-log;
2262                shProg->LinkStatus = GL_FALSE;
2263             }
2264 #endif
2265          }
2266          if (sh->InfoLog)
2267             ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
2268       }
2269
2270       delete_shader(ctx, shader);
2271    }
2272
2273    return program;
2274 }
2275
2276
2277 /**
2278  * For GL_ARB_tessellation_shader
2279  */
2280 extern void GLAPIENTRY
2281 _mesa_PatchParameteri(GLenum pname, GLint value)
2282 {
2283    GET_CURRENT_CONTEXT(ctx);
2284
2285    if (!_mesa_has_tessellation(ctx)) {
2286       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameteri");
2287       return;
2288    }
2289
2290    if (pname != GL_PATCH_VERTICES) {
2291       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameteri");
2292       return;
2293    }
2294
2295    if (value <= 0 || value > ctx->Const.MaxPatchVertices) {
2296       _mesa_error(ctx, GL_INVALID_VALUE, "glPatchParameteri");
2297       return;
2298    }
2299
2300    ctx->TessCtrlProgram.patch_vertices = value;
2301 }
2302
2303
2304 extern void GLAPIENTRY
2305 _mesa_PatchParameterfv(GLenum pname, const GLfloat *values)
2306 {
2307    GET_CURRENT_CONTEXT(ctx);
2308
2309    if (!_mesa_has_tessellation(ctx)) {
2310       _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameterfv");
2311       return;
2312    }
2313
2314    switch(pname) {
2315    case GL_PATCH_DEFAULT_OUTER_LEVEL:
2316       FLUSH_VERTICES(ctx, 0);
2317       memcpy(ctx->TessCtrlProgram.patch_default_outer_level, values,
2318              4 * sizeof(GLfloat));
2319       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2320       return;
2321    case GL_PATCH_DEFAULT_INNER_LEVEL:
2322       FLUSH_VERTICES(ctx, 0);
2323       memcpy(ctx->TessCtrlProgram.patch_default_inner_level, values,
2324              2 * sizeof(GLfloat));
2325       ctx->NewDriverState |= ctx->DriverFlags.NewDefaultTessLevels;
2326       return;
2327    default:
2328       _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameterfv");
2329       return;
2330    }
2331 }
2332
2333 /**
2334  * ARB_shader_subroutine
2335  */
2336 GLint GLAPIENTRY
2337 _mesa_GetSubroutineUniformLocation(GLuint program, GLenum shadertype,
2338                                    const GLchar *name)
2339 {
2340    GET_CURRENT_CONTEXT(ctx);
2341    const char *api_name = "glGetSubroutineUniformLocation";
2342    struct gl_shader_program *shProg;
2343    GLenum resource_type;
2344    gl_shader_stage stage;
2345
2346    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2347       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2348       return -1;
2349    }
2350
2351    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2352       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2353       return -1;
2354    }
2355
2356    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2357    if (!shProg)
2358       return -1;
2359
2360    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2361    if (!shProg->_LinkedShaders[stage]) {
2362       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2363       return -1;
2364    }
2365
2366    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2367    return _mesa_program_resource_location(shProg, resource_type, name);
2368 }
2369
2370 GLuint GLAPIENTRY
2371 _mesa_GetSubroutineIndex(GLuint program, GLenum shadertype,
2372                          const GLchar *name)
2373 {
2374    GET_CURRENT_CONTEXT(ctx);
2375    const char *api_name = "glGetSubroutineIndex";
2376    struct gl_shader_program *shProg;
2377    struct gl_program_resource *res;
2378    GLenum resource_type;
2379    gl_shader_stage stage;
2380
2381    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2382       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2383       return -1;
2384    }
2385
2386    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2387       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2388       return -1;
2389    }
2390
2391    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2392    if (!shProg)
2393       return -1;
2394
2395    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2396    if (!shProg->_LinkedShaders[stage]) {
2397       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2398       return -1;
2399    }
2400
2401    resource_type = _mesa_shader_stage_to_subroutine(stage);
2402    res = _mesa_program_resource_find_name(shProg, resource_type, name, NULL);
2403    if (!res) {
2404      return -1;
2405    }
2406
2407    return _mesa_program_resource_index(shProg, res);
2408 }
2409
2410
2411 GLvoid GLAPIENTRY
2412 _mesa_GetActiveSubroutineUniformiv(GLuint program, GLenum shadertype,
2413                                    GLuint index, GLenum pname, GLint *values)
2414 {
2415    GET_CURRENT_CONTEXT(ctx);
2416    const char *api_name = "glGetActiveSubroutineUniformiv";
2417    struct gl_shader_program *shProg;
2418    struct gl_linked_shader *sh;
2419    gl_shader_stage stage;
2420    struct gl_program_resource *res;
2421    const struct gl_uniform_storage *uni;
2422    GLenum resource_type;
2423    int count, i, j;
2424
2425    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2426       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2427       return;
2428    }
2429
2430    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2431       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2432       return;
2433    }
2434
2435    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2436    if (!shProg)
2437       return;
2438
2439    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2440    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2441
2442    sh = shProg->_LinkedShaders[stage];
2443    if (!sh) {
2444       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2445       return;
2446    }
2447
2448    if (index >= sh->NumSubroutineUniforms) {
2449       _mesa_error(ctx, GL_INVALID_VALUE, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name);
2450       return;
2451    }
2452
2453    switch (pname) {
2454    case GL_NUM_COMPATIBLE_SUBROUTINES: {
2455       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2456       if (res) {
2457          uni = res->Data;
2458          values[0] = uni->num_compatible_subroutines;
2459       }
2460       break;
2461    }
2462    case GL_COMPATIBLE_SUBROUTINES: {
2463       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2464       if (res) {
2465          uni = res->Data;
2466          count = 0;
2467          for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2468             struct gl_subroutine_function *fn = &sh->SubroutineFunctions[i];
2469             for (j = 0; j < fn->num_compat_types; j++) {
2470                if (fn->types[j] == uni->type) {
2471                   values[count++] = i;
2472                   break;
2473                }
2474             }
2475          }
2476       }
2477       break;
2478    }
2479    case GL_UNIFORM_SIZE:
2480       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2481       if (res) {
2482          uni = res->Data;
2483          values[0] = uni->array_elements ? uni->array_elements : 1;
2484       }
2485       break;
2486    case GL_UNIFORM_NAME_LENGTH:
2487       res = _mesa_program_resource_find_index(shProg, resource_type, index);
2488       if (res) {
2489          values[0] = strlen(_mesa_program_resource_name(res)) + 1
2490             + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);
2491       }
2492       break;
2493    default:
2494       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2495       return;
2496    }
2497 }
2498
2499
2500 GLvoid GLAPIENTRY
2501 _mesa_GetActiveSubroutineUniformName(GLuint program, GLenum shadertype,
2502                                      GLuint index, GLsizei bufsize,
2503                                      GLsizei *length, GLchar *name)
2504 {
2505    GET_CURRENT_CONTEXT(ctx);
2506    const char *api_name = "glGetActiveSubroutineUniformName";
2507    struct gl_shader_program *shProg;
2508    GLenum resource_type;
2509    gl_shader_stage stage;
2510
2511    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2512       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2513       return;
2514    }
2515
2516    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2517       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2518       return;
2519    }
2520
2521    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2522    if (!shProg)
2523       return;
2524
2525    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2526    if (!shProg->_LinkedShaders[stage]) {
2527       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2528       return;
2529    }
2530
2531    resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2532    /* get program resource name */
2533    _mesa_get_program_resource_name(shProg, resource_type,
2534                                    index, bufsize,
2535                                    length, name, api_name);
2536 }
2537
2538
2539 GLvoid GLAPIENTRY
2540 _mesa_GetActiveSubroutineName(GLuint program, GLenum shadertype,
2541                               GLuint index, GLsizei bufsize,
2542                               GLsizei *length, GLchar *name)
2543 {
2544    GET_CURRENT_CONTEXT(ctx);
2545    const char *api_name = "glGetActiveSubroutineName";
2546    struct gl_shader_program *shProg;
2547    GLenum resource_type;
2548    gl_shader_stage stage;
2549
2550    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2551       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2552       return;
2553    }
2554
2555    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2556       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2557       return;
2558    }
2559
2560    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2561    if (!shProg)
2562       return;
2563
2564    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2565    if (!shProg->_LinkedShaders[stage]) {
2566       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2567       return;
2568    }
2569    resource_type = _mesa_shader_stage_to_subroutine(stage);
2570    _mesa_get_program_resource_name(shProg, resource_type,
2571                                    index, bufsize,
2572                                    length, name, api_name);
2573 }
2574
2575 GLvoid GLAPIENTRY
2576 _mesa_UniformSubroutinesuiv(GLenum shadertype, GLsizei count,
2577                             const GLuint *indices)
2578 {
2579    GET_CURRENT_CONTEXT(ctx);
2580    const char *api_name = "glUniformSubroutinesuiv";
2581    struct gl_shader_program *shProg;
2582    struct gl_linked_shader *sh;
2583    gl_shader_stage stage;
2584    int i;
2585
2586    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2587       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2588       return;
2589    }
2590
2591    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2592       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2593       return;
2594    }
2595
2596    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2597    shProg = ctx->_Shader->CurrentProgram[stage];
2598    if (!shProg) {
2599       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2600       return;
2601    }
2602
2603    sh = shProg->_LinkedShaders[stage];
2604    if (!sh) {
2605       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2606       return;
2607    }
2608
2609    if (count != sh->NumSubroutineUniformRemapTable) {
2610       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2611       return;
2612    }
2613
2614    i = 0;
2615    do {
2616       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2617       if (uni == NULL) {
2618          i++;
2619          continue;
2620       }
2621
2622       int uni_count = uni->array_elements ? uni->array_elements : 1;
2623       int j, k, f;
2624
2625       for (j = i; j < i + uni_count; j++) {
2626          struct gl_subroutine_function *subfn = NULL;
2627          if (indices[j] > sh->MaxSubroutineFunctionIndex) {
2628             _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2629             return;
2630          }
2631
2632          for (f = 0; f < sh->NumSubroutineFunctions; f++) {
2633             if (sh->SubroutineFunctions[f].index == indices[j])
2634                subfn = &sh->SubroutineFunctions[f];
2635          }
2636
2637          if (!subfn) {
2638             continue;
2639          }
2640
2641          for (k = 0; k < subfn->num_compat_types; k++) {
2642             if (subfn->types[k] == uni->type)
2643                break;
2644          }
2645          if (k == subfn->num_compat_types) {
2646             _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2647             return;
2648          }
2649
2650          ctx->SubroutineIndex[sh->Stage].IndexPtr[j] = indices[j];
2651       }
2652       i += uni_count;
2653    } while(i < count);
2654
2655    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
2656 }
2657
2658
2659 GLvoid GLAPIENTRY
2660 _mesa_GetUniformSubroutineuiv(GLenum shadertype, GLint location,
2661                               GLuint *params)
2662 {
2663    GET_CURRENT_CONTEXT(ctx);
2664    const char *api_name = "glGetUniformSubroutineuiv";
2665    struct gl_shader_program *shProg;
2666    struct gl_linked_shader *sh;
2667    gl_shader_stage stage;
2668
2669    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2670       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2671       return;
2672    }
2673
2674    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2675       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2676       return;
2677    }
2678
2679    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2680    shProg = ctx->_Shader->CurrentProgram[stage];
2681    if (!shProg) {
2682       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2683       return;
2684    }
2685
2686    sh = shProg->_LinkedShaders[stage];
2687    if (!sh) {
2688       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2689       return;
2690    }
2691
2692    if (location >= sh->NumSubroutineUniformRemapTable) {
2693       _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
2694       return;
2695    }
2696
2697    *params = ctx->SubroutineIndex[sh->Stage].IndexPtr[location];
2698 }
2699
2700
2701 GLvoid GLAPIENTRY
2702 _mesa_GetProgramStageiv(GLuint program, GLenum shadertype,
2703                         GLenum pname, GLint *values)
2704 {
2705    GET_CURRENT_CONTEXT(ctx);
2706    const char *api_name = "glGetProgramStageiv";
2707    struct gl_shader_program *shProg;
2708    struct gl_linked_shader *sh;
2709    gl_shader_stage stage;
2710
2711    if (!_mesa_has_ARB_shader_subroutine(ctx)) {
2712       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2713       return;
2714    }
2715
2716    if (!_mesa_validate_shader_target(ctx, shadertype)) {
2717       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2718       return;
2719    }
2720
2721    shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2722    if (!shProg)
2723       return;
2724
2725    stage = _mesa_shader_enum_to_shader_stage(shadertype);
2726    sh = shProg->_LinkedShaders[stage];
2727
2728    /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
2729     * INVALID_OPERATION in the case of not be linked.
2730     *
2731     * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
2732     * same info using other specs (ARB_program_interface_query), without the
2733     * need of the program to be linked, being the value for that case 0.
2734     *
2735     * But at the same time, some other methods require the program to be
2736     * linked for pname related to locations, so it would be inconsistent to
2737     * not do the same here. So we are:
2738     *   * Return GL_INVALID_OPERATION if not linked only for locations.
2739     *   * Setting a default value of 0, to be returned if not linked.
2740     */
2741    if (!sh) {
2742       values[0] = 0;
2743       if (pname == GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS) {
2744          _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2745       }
2746       return;
2747    }
2748
2749    switch (pname) {
2750    case GL_ACTIVE_SUBROUTINES:
2751       values[0] = sh->NumSubroutineFunctions;
2752       break;
2753    case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS:
2754       values[0] = sh->NumSubroutineUniformRemapTable;
2755       break;
2756    case GL_ACTIVE_SUBROUTINE_UNIFORMS:
2757       values[0] = sh->NumSubroutineUniforms;
2758       break;
2759    case GL_ACTIVE_SUBROUTINE_MAX_LENGTH:
2760    {
2761       unsigned i;
2762       GLint max_len = 0;
2763       GLenum resource_type;
2764       struct gl_program_resource *res;
2765
2766       resource_type = _mesa_shader_stage_to_subroutine(stage);
2767       for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2768          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2769          if (res) {
2770             const GLint len = strlen(_mesa_program_resource_name(res)) + 1;
2771             if (len > max_len)
2772                max_len = len;
2773          }
2774       }
2775       values[0] = max_len;
2776       break;
2777    }
2778    case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH:
2779    {
2780       unsigned i;
2781       GLint max_len = 0;
2782       GLenum resource_type;
2783       struct gl_program_resource *res;
2784
2785       resource_type = _mesa_shader_stage_to_subroutine_uniform(stage);
2786       for (i = 0; i < sh->NumSubroutineUniformRemapTable; i++) {
2787          res = _mesa_program_resource_find_index(shProg, resource_type, i);
2788          if (res) {
2789             const GLint len = strlen(_mesa_program_resource_name(res)) + 1
2790                + ((_mesa_program_resource_array_size(res) != 0) ? 3 : 0);
2791
2792             if (len > max_len)
2793                max_len = len;
2794          }
2795       }
2796       values[0] = max_len;
2797       break;
2798    }
2799    default:
2800       _mesa_error(ctx, GL_INVALID_ENUM, "%s", api_name);
2801       values[0] = -1;
2802       break;
2803    }
2804 }
2805
2806 static int
2807 find_compat_subroutine(struct gl_linked_shader *sh,
2808                        const struct glsl_type *type)
2809 {
2810    int i, j;
2811
2812    for (i = 0; i < sh->NumSubroutineFunctions; i++) {
2813       struct gl_subroutine_function *fn = &sh->SubroutineFunctions[i];
2814       for (j = 0; j < fn->num_compat_types; j++) {
2815          if (fn->types[j] == type)
2816             return i;
2817       }
2818    }
2819    return 0;
2820 }
2821
2822 static void
2823 _mesa_shader_write_subroutine_index(struct gl_context *ctx,
2824                                     struct gl_linked_shader *sh)
2825 {
2826    int i, j;
2827
2828    if (sh->NumSubroutineUniformRemapTable == 0)
2829       return;
2830
2831    i = 0;
2832    do {
2833       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2834       int uni_count;
2835       int val;
2836
2837       if (!uni) {
2838          i++;
2839          continue;
2840       }
2841
2842       uni_count = uni->array_elements ? uni->array_elements : 1;
2843       for (j = 0; j < uni_count; j++) {
2844          val = ctx->SubroutineIndex[sh->Stage].IndexPtr[i + j];
2845          memcpy(&uni->storage[j], &val, sizeof(int));
2846       }
2847
2848       _mesa_propagate_uniforms_to_driver_storage(uni, 0, uni_count);
2849       i += uni_count;
2850    } while(i < sh->NumSubroutineUniformRemapTable);
2851 }
2852
2853 void
2854 _mesa_shader_write_subroutine_indices(struct gl_context *ctx,
2855                                       gl_shader_stage stage)
2856 {
2857    if (ctx->_Shader->CurrentProgram[stage] &&
2858        ctx->_Shader->CurrentProgram[stage]->_LinkedShaders[stage])
2859       _mesa_shader_write_subroutine_index(ctx,
2860                                           ctx->_Shader->CurrentProgram[stage]->_LinkedShaders[stage]);
2861 }
2862
2863 static void
2864 _mesa_shader_init_subroutine_defaults(struct gl_context *ctx,
2865                                       struct gl_linked_shader *sh)
2866 {
2867    int i;
2868    struct gl_subroutine_index_binding *binding = &ctx->SubroutineIndex[sh->Stage];
2869    if (binding->NumIndex != sh->NumSubroutineUniformRemapTable) {
2870       binding->IndexPtr = realloc(binding->IndexPtr,
2871                                   sh->NumSubroutineUniformRemapTable * (sizeof(GLuint)));
2872       binding->NumIndex = sh->NumSubroutineUniformRemapTable;
2873    }
2874
2875    for (i = 0; i < sh->NumSubroutineUniformRemapTable; i++) {
2876       struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[i];
2877
2878       if (!uni)
2879          continue;
2880
2881       binding->IndexPtr[i] = find_compat_subroutine(sh, uni->type);
2882    }
2883 }
2884
2885 void
2886 _mesa_shader_program_init_subroutine_defaults(struct gl_context *ctx,
2887                                               struct gl_shader_program *shProg)
2888 {
2889    int i;
2890
2891    if (!shProg)
2892       return;
2893
2894    for (i = 0; i < MESA_SHADER_STAGES; i++) {
2895       if (!shProg->_LinkedShaders[i])
2896          continue;
2897
2898       _mesa_shader_init_subroutine_defaults(ctx, shProg->_LinkedShaders[i]);
2899    }
2900 }