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