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