src/mesa/main/shaderapi.c

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