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 "main/glheader.h"
  41 #include "main/context.h"
  42 #include "main/dispatch.h"
  43 #include "main/enums.h"
  44 #include "main/hash.h"
  45 #include "main/hash_table.h"
  46 #include "main/mtypes.h"
  47 #include "main/shaderapi.h"
  48 #include "main/shaderobj.h"
  49 #include "main/transformfeedback.h"
  50 #include "main/uniforms.h"
  51 #include "program/program.h"
  52 #include "program/prog_print.h"
  53 #include "program/prog_parameter.h"
  54 #include "ralloc.h"
  55 #include <stdbool.h>
  56 #include "../glsl/glsl_parser_extras.h"
  57 #include "../glsl/ir.h"
  58 #include "../glsl/ir_uniform.h"
  59 #include "../glsl/program.h"
  60
  61 /** Define this to enable shader substitution (see below) */
  62 #define SHADER_SUBST 0
  63
  64
  65 /**
  66  * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
  67  */
  68 GLbitfield
  69 _mesa_get_shader_flags(void)
  70 {
  71    GLbitfield flags = 0x0;
  72    const char *env = _mesa_getenv("MESA_GLSL");
  73
  74    if (env) {
  75       if (strstr(env, "dump_on_error"))
  76          flags |= GLSL_DUMP_ON_ERROR;
  77       else if (strstr(env, "dump"))
  78          flags |= GLSL_DUMP;
  79       if (strstr(env, "log"))
  80          flags |= GLSL_LOG;
  81       if (strstr(env, "nopvert"))
  82          flags |= GLSL_NOP_VERT;
  83       if (strstr(env, "nopfrag"))
  84          flags |= GLSL_NOP_FRAG;
  85       if (strstr(env, "nopt"))
  86          flags |= GLSL_NO_OPT;
  87       else if (strstr(env, "opt"))
  88          flags |= GLSL_OPT;
  89       if (strstr(env, "uniform"))
  90          flags |= GLSL_UNIFORMS;
  91       if (strstr(env, "useprog"))
  92          flags |= GLSL_USE_PROG;
  93       if (strstr(env, "errors"))
  94          flags |= GLSL_REPORT_ERRORS;
  95    }
  96
  97    return flags;
  98 }
  99
 100
 101 /**
 102  * Initialize context's shader state.
 103  */
 104 void
 105 _mesa_init_shader_state(struct gl_context *ctx)
 106 {
 107    /* Device drivers may override these to control what kind of instructions
 108     * are generated by the GLSL compiler.
 109     */
 110    struct gl_shader_compiler_options options;
 111    gl_shader_stage sh;
 112
 113    memset(&options, 0, sizeof(options));
 114    options.MaxUnrollIterations = 32;
 115    options.MaxIfDepth = UINT_MAX;
 116
 117    /* Default pragma settings */
 118    options.DefaultPragmas.Optimize = GL_TRUE;
 119
 120    for (sh = 0; sh < MESA_SHADER_STAGES; ++sh)
 121       memcpy(&ctx->ShaderCompilerOptions[sh], &options, sizeof(options));
 122
 123    ctx->Shader.Flags = _mesa_get_shader_flags();
 124
 125    /* Extended for ARB_separate_shader_objects */
 126    ctx->Shader.RefCount = 1;
 127    _glthread_INIT_MUTEX(ctx->Shader.Mutex);
 128 }
 129
 130
 131 /**
 132  * Free the per-context shader-related state.
 133  */
 134 void
 135 _mesa_free_shader_state(struct gl_context *ctx)
 136 {
 137    int i;
 138    for (i = 0; i < MESA_SHADER_STAGES; i++) {
 139       _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram[i],
 140                                      NULL);
 141    }
 142    _mesa_reference_shader_program(ctx, &ctx->Shader._CurrentFragmentProgram,
 143                                   NULL);
 144    _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL);
 145
 146    /* Extended for ARB_separate_shader_objects */
 147    assert(ctx->Shader.RefCount == 1);
 148    _glthread_DESTROY_MUTEX(ctx->Shader.Mutex);
 149 }
 150
 151
 152 /**
 153  * Copy string from <src> to <dst>, up to maxLength characters, returning
 154  * length of <dst> in <length>.
 155  * \param src  the strings source
 156  * \param maxLength  max chars to copy
 157  * \param length  returns number of chars copied
 158  * \param dst  the string destination
 159  */
 160 void
 161 _mesa_copy_string(GLchar *dst, GLsizei maxLength,
 162                   GLsizei *length, const GLchar *src)
 163 {
 164    GLsizei len;
 165    for (len = 0; len < maxLength - 1 && src && src[len]; len++)
 166       dst[len] = src[len];
 167    if (maxLength > 0)
 168       dst[len] = 0;
 169    if (length)
 170       *length = len;
 171 }
 172
 173
 174
 175 /**
 176  * Confirm that the a shader type is valid and supported by the implementation
 177  *
 178  * \param ctx   Current GL context
 179  * \param type  Shader target
 180  *
 181  */
 182 bool
 183 _mesa_validate_shader_target(const struct gl_context *ctx, GLenum type)
 184 {
 185    /* Note: when building built-in GLSL functions, this function may be
 186     * invoked with ctx == NULL.  In that case, we can only validate that it's
 187     * a shader target we recognize, not that it's supported in the current
 188     * context.  But that's fine--we don't need any further validation than
 189     * that when building built-in GLSL functions.
 190     */
 191
 192    switch (type) {
 193    case GL_FRAGMENT_SHADER:
 194       return ctx == NULL || ctx->Extensions.ARB_fragment_shader;
 195    case GL_VERTEX_SHADER:
 196       return ctx == NULL || ctx->Extensions.ARB_vertex_shader;
 197    case GL_GEOMETRY_SHADER_ARB:
 198       return ctx == NULL || _mesa_has_geometry_shaders(ctx);
 199    case GL_COMPUTE_SHADER:
 200       return ctx == NULL || ctx->Extensions.ARB_compute_shader;
 201    default:
 202       return false;
 203    }
 204 }
 205
 206
 207 static GLboolean
 208 is_program(struct gl_context *ctx, GLuint name)
 209 {
 210    struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
 211    return shProg ? GL_TRUE : GL_FALSE;
 212 }
 213
 214
 215 static GLboolean
 216 is_shader(struct gl_context *ctx, GLuint name)
 217 {
 218    struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
 219    return shader ? GL_TRUE : GL_FALSE;
 220 }
 221
 222
 223 /**
 224  * Attach shader to a shader program.
 225  */
 226 static void
 227 attach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
 228 {
 229    struct gl_shader_program *shProg;
 230    struct gl_shader *sh;
 231    GLuint i, n;
 232
 233    const bool same_type_disallowed = _mesa_is_gles(ctx);
 234
 235    shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");
 236    if (!shProg)
 237       return;
 238
 239    sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");
 240    if (!sh) {
 241       return;
 242    }
 243
 244    n = shProg->NumShaders;
 245    for (i = 0; i < n; i++) {
 246       if (shProg->Shaders[i] == sh) {
 247          /* The shader is already attched to this program.  The
 248           * GL_ARB_shader_objects spec says:
 249           *
 250           *     "The error INVALID_OPERATION is generated by AttachObjectARB
 251           *     if <obj> is already attached to <containerObj>."
 252           */
 253          _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");
 254          return;
 255       } else if (same_type_disallowed &&
 256                  shProg->Shaders[i]->Type == sh->Type) {
 257         /* Shader with the same type is already attached to this program,
 258          * OpenGL ES 2.0 and 3.0 specs say:
 259          *
 260          *      "Multiple shader objects of the same type may not be attached
 261          *      to a single program object. [...] The error INVALID_OPERATION
 262          *      is generated if [...] another shader object of the same type
 263          *      as shader is already attached to program."
 264          */
 265          _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");
 266          return;
 267       }
 268    }
 269
 270    /* grow list */
 271    shProg->Shaders = (struct gl_shader **)
 272       _mesa_realloc(shProg->Shaders,
 273                     n * sizeof(struct gl_shader *),
 274                     (n + 1) * sizeof(struct gl_shader *));
 275    if (!shProg->Shaders) {
 276       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
 277       return;
 278    }
 279
 280    /* append */
 281    shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
 282    _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
 283    shProg->NumShaders++;
 284 }
 285
 286
 287 static GLuint
 288 create_shader(struct gl_context *ctx, GLenum type)
 289 {
 290    struct gl_shader *sh;
 291    GLuint name;
 292
 293    if (!_mesa_validate_shader_target(ctx, type)) {
 294       _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
 295       return 0;
 296    }
 297
 298    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 299    sh = ctx->Driver.NewShader(ctx, name, type);
 300    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);
 301
 302    return name;
 303 }
 304
 305
 306 static GLuint
 307 create_shader_program(struct gl_context *ctx)
 308 {
 309    GLuint name;
 310    struct gl_shader_program *shProg;
 311
 312    name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
 313
 314    shProg = ctx->Driver.NewShaderProgram(ctx, name);
 315
 316    _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);
 317
 318    assert(shProg->RefCount == 1);
 319
 320    return name;
 321 }
 322
 323
 324 /**
 325  * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
 326  * DeleteProgramARB.
 327  */
 328 static void
 329 delete_shader_program(struct gl_context *ctx, GLuint name)
 330 {
 331    /*
 332     * NOTE: deleting shaders/programs works a bit differently than
 333     * texture objects (and buffer objects, etc).  Shader/program
 334     * handles/IDs exist in the hash table until the object is really
 335     * deleted (refcount==0).  With texture objects, the handle/ID is
 336     * removed from the hash table in glDeleteTextures() while the tex
 337     * object itself might linger until its refcount goes to zero.
 338     */
 339    struct gl_shader_program *shProg;
 340
 341    shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
 342    if (!shProg)
 343       return;
 344
 345    if (!shProg->DeletePending) {
 346       shProg->DeletePending = GL_TRUE;
 347
 348       /* effectively, decr shProg's refcount */
 349       _mesa_reference_shader_program(ctx, &shProg, NULL);
 350    }
 351 }
 352
 353
 354 static void
 355 delete_shader(struct gl_context *ctx, GLuint shader)
 356 {
 357    struct gl_shader *sh;
 358
 359    sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
 360    if (!sh)
 361       return;
 362
 363    if (!sh->DeletePending) {
 364       sh->DeletePending = GL_TRUE;
 365
 366       /* effectively, decr sh's refcount */
 367       _mesa_reference_shader(ctx, &sh, NULL);
 368    }
 369 }
 370
 371
 372 static void
 373 detach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
 374 {
 375    struct gl_shader_program *shProg;
 376    GLuint n;
 377    GLuint i, j;
 378
 379    shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");
 380    if (!shProg)
 381       return;
 382
 383    n = shProg->NumShaders;
 384
 385    for (i = 0; i < n; i++) {
 386       if (shProg->Shaders[i]->Name == shader) {
 387          /* found it */
 388          struct gl_shader **newList;
 389
 390          /* release */
 391          _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
 392
 393          /* alloc new, smaller array */
 394          newList = malloc((n - 1) * sizeof(struct gl_shader *));
 395          if (!newList) {
 396             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
 397             return;
 398          }
 399          /* Copy old list entries to new list, skipping removed entry at [i] */
 400          for (j = 0; j < i; j++) {
 401             newList[j] = shProg->Shaders[j];
 402          }
 403          while (++i < n) {
 404             newList[j++] = shProg->Shaders[i];
 405          }
 406
 407          /* Free old list and install new one */
 408          free(shProg->Shaders);
 409          shProg->Shaders = newList;
 410          shProg->NumShaders = n - 1;
 411
 412 #ifdef DEBUG
 413          /* sanity check - make sure the new list's entries are sensible */
 414          for (j = 0; j < shProg->NumShaders; j++) {
 415             assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||
 416                    shProg->Shaders[j]->Type == GL_GEOMETRY_SHADER ||
 417                    shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);
 418             assert(shProg->Shaders[j]->RefCount > 0);
 419          }
 420 #endif
 421
 422          return;
 423       }
 424    }
 425
 426    /* not found */
 427    {
 428       GLenum err;
 429       if (is_shader(ctx, shader))
 430          err = GL_INVALID_OPERATION;
 431       else if (is_program(ctx, shader))
 432          err = GL_INVALID_OPERATION;
 433       else
 434          err = GL_INVALID_VALUE;
 435       _mesa_error(ctx, err, "glDetachShader(shader)");
 436       return;
 437    }
 438 }
 439
 440
 441 /**
 442  * Return list of shaders attached to shader program.
 443  */
 444 static void
 445 get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount,
 446                      GLsizei *count, GLuint *obj)
 447 {
 448    struct gl_shader_program *shProg =
 449       _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");
 450    if (shProg) {
 451       GLuint i;
 452       for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {
 453          obj[i] = shProg->Shaders[i]->Name;
 454       }
 455       if (count)
 456          *count = i;
 457    }
 458 }
 459
 460
 461 /**
 462  * glGetHandleARB() - return ID/name of currently bound shader program.
 463  */
 464 static GLuint
 465 get_handle(struct gl_context *ctx, GLenum pname)
 466 {
 467    if (pname == GL_PROGRAM_OBJECT_ARB) {
 468       if (ctx->Shader.ActiveProgram)
 469          return ctx->Shader.ActiveProgram->Name;
 470       else
 471          return 0;
 472    }
 473    else {
 474       _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
 475       return 0;
 476    }
 477 }
 478
 479
 480 /**
 481  * Check if a geometry shader query is valid at this time.  If not, report an
 482  * error and return false.
 483  *
 484  * From GL 3.2 section 6.1.16 (Shader and Program Queries):
 485  *
 486  *     "If GEOMETRY_VERTICES_OUT, GEOMETRY_INPUT_TYPE, or GEOMETRY_OUTPUT_TYPE
 487  *     are queried for a program which has not been linked successfully, or
 488  *     which does not contain objects to form a geometry shader, then an
 489  *     INVALID_OPERATION error is generated."
 490  */
 491 static bool
 492 check_gs_query(struct gl_context *ctx, const struct gl_shader_program *shProg)
 493 {
 494    if (shProg->LinkStatus &&
 495        shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] != NULL) {
 496       return true;
 497    }
 498
 499    _mesa_error(ctx, GL_INVALID_OPERATION,
 500                "glGetProgramv(linked geometry shader required)");
 501    return false;
 502 }
 503
 504
 505 /**
 506  * glGetProgramiv() - get shader program state.
 507  * Note that this is for GLSL shader programs, not ARB vertex/fragment
 508  * programs (see glGetProgramivARB).
 509  */
 510 static void
 511 get_programiv(struct gl_context *ctx, GLuint program, GLenum pname, GLint *params)
 512 {
 513    struct gl_shader_program *shProg
 514       = _mesa_lookup_shader_program(ctx, program);
 515
 516    /* Is transform feedback available in this context?
 517     */
 518    const bool has_xfb =
 519       (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.EXT_transform_feedback)
 520       || ctx->API == API_OPENGL_CORE
 521       || _mesa_is_gles3(ctx);
 522
 523    /* True if geometry shaders (of the form that was adopted into GLSL 1.50
 524     * and GL 3.2) are available in this context
 525     */
 526    const bool has_core_gs = _mesa_is_desktop_gl(ctx) && ctx->Version >= 32;
 527
 528    /* Are uniform buffer objects available in this context?
 529     */
 530    const bool has_ubo =
 531       (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.ARB_uniform_buffer_object)
 532       || ctx->API == API_OPENGL_CORE
 533       || _mesa_is_gles3(ctx);
 534
 535    if (!shProg) {
 536       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
 537       return;
 538    }
 539
 540    switch (pname) {
 541    case GL_DELETE_STATUS:
 542       *params = shProg->DeletePending;
 543       return;
 544    case GL_LINK_STATUS:
 545       *params = shProg->LinkStatus;
 546       return;
 547    case GL_VALIDATE_STATUS:
 548       *params = shProg->Validated;
 549       return;
 550    case GL_INFO_LOG_LENGTH:
 551       *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
 552       return;
 553    case GL_ATTACHED_SHADERS:
 554       *params = shProg->NumShaders;
 555       return;
 556    case GL_ACTIVE_ATTRIBUTES:
 557       *params = _mesa_count_active_attribs(shProg);
 558       return;
 559    case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
 560       *params = _mesa_longest_attribute_name_length(shProg);
 561       return;
 562    case GL_ACTIVE_UNIFORMS:
 563       *params = shProg->NumUserUniformStorage;
 564       return;
 565    case GL_ACTIVE_UNIFORM_MAX_LENGTH: {
 566       unsigned i;
 567       GLint max_len = 0;
 568
 569       for (i = 0; i < shProg->NumUserUniformStorage; i++) {
 570          /* Add one for the terminating NUL character for a non-array, and
 571           * 4 for the "[0]" and the NUL for an array.
 572           */
 573          const GLint len = strlen(shProg->UniformStorage[i].name) + 1 +
 574              ((shProg->UniformStorage[i].array_elements != 0) ? 3 : 0);
 575
 576          if (len > max_len)
 577             max_len = len;
 578       }
 579
 580       *params = max_len;
 581       return;
 582    }
 583    case GL_TRANSFORM_FEEDBACK_VARYINGS:
 584       if (!has_xfb)
 585          break;
 586       *params = shProg->TransformFeedback.NumVarying;
 587       return;
 588    case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: {
 589       unsigned i;
 590       GLint max_len = 0;
 591       if (!has_xfb)
 592          break;
 593
 594       for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
 595          /* Add one for the terminating NUL character.
 596           */
 597          const GLint len = strlen(shProg->TransformFeedback.VaryingNames[i]) + 1;
 598
 599          if (len > max_len)
 600             max_len = len;
 601       }
 602
 603       *params = max_len;
 604       return;
 605    }
 606    case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
 607       if (!has_xfb)
 608          break;
 609       *params = shProg->TransformFeedback.BufferMode;
 610       return;
 611    case GL_GEOMETRY_VERTICES_OUT:
 612       if (!has_core_gs)
 613          break;
 614       if (check_gs_query(ctx, shProg))
 615          *params = shProg->Geom.VerticesOut;
 616       return;
 617    case GL_GEOMETRY_SHADER_INVOCATIONS:
 618       if (!has_core_gs || !ctx->Extensions.ARB_gpu_shader5)
 619          break;
 620       if (check_gs_query(ctx, shProg))
 621          *params = shProg->Geom.Invocations;
 622       return;
 623    case GL_GEOMETRY_INPUT_TYPE:
 624       if (!has_core_gs)
 625          break;
 626       if (check_gs_query(ctx, shProg))
 627          *params = shProg->Geom.InputType;
 628       return;
 629    case GL_GEOMETRY_OUTPUT_TYPE:
 630       if (!has_core_gs)
 631          break;
 632       if (check_gs_query(ctx, shProg))
 633          *params = shProg->Geom.OutputType;
 634       return;
 635    case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: {
 636       unsigned i;
 637       GLint max_len = 0;
 638
 639       if (!has_ubo)
 640          break;
 641
 642       for (i = 0; i < shProg->NumUniformBlocks; i++) {
 643          /* Add one for the terminating NUL character.
 644           */
 645          const GLint len = strlen(shProg->UniformBlocks[i].Name) + 1;
 646
 647          if (len > max_len)
 648             max_len = len;
 649       }
 650
 651       *params = max_len;
 652       return;
 653    }
 654    case GL_ACTIVE_UNIFORM_BLOCKS:
 655       if (!has_ubo)
 656          break;
 657
 658       *params = shProg->NumUniformBlocks;
 659       return;
 660    case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
 661       /* This enum isn't part of the OES extension for OpenGL ES 2.0.  It is
 662        * only available with desktop OpenGL 3.0+ with the
 663        * GL_ARB_get_program_binary extension or OpenGL ES 3.0.
 664        *
 665        * On desktop, we ignore the 3.0+ requirement because it is silly.
 666        */
 667       if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx))
 668          break;
 669
 670       *params = shProg->BinaryRetreivableHint;
 671       return;
 672    case GL_PROGRAM_BINARY_LENGTH:
 673       *params = 0;
 674       return;
 675    case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS:
 676       if (!ctx->Extensions.ARB_shader_atomic_counters)
 677          break;
 678
 679       *params = shProg->NumAtomicBuffers;
 680       return;
 681    case GL_COMPUTE_WORK_GROUP_SIZE: {
 682       int i;
 683       if (!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_compute_shader)
 684          break;
 685       if (!shProg->LinkStatus) {
 686          _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramiv(program not "
 687                      "linked)");
 688          return;
 689       }
 690       if (shProg->_LinkedShaders[MESA_SHADER_COMPUTE] == NULL) {
 691          _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramiv(no compute "
 692                      "shaders)");
 693          return;
 694       }
 695       for (i = 0; i < 3; i++)
 696          params[i] = shProg->Comp.LocalSize[i];
 697       return;
 698    }
 699    default:
 700       break;
 701    }
 702
 703    _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname=%s)",
 704                _mesa_lookup_enum_by_nr(pname));
 705 }
 706
 707
 708 /**
 709  * glGetShaderiv() - get GLSL shader state
 710  */
 711 static void
 712 get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)
 713 {
 714    struct gl_shader *shader =
 715       _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");
 716
 717    if (!shader) {
 718       return;
 719    }
 720
 721    switch (pname) {
 722    case GL_SHADER_TYPE:
 723       *params = shader->Type;
 724       break;
 725    case GL_DELETE_STATUS:
 726       *params = shader->DeletePending;
 727       break;
 728    case GL_COMPILE_STATUS:
 729       *params = shader->CompileStatus;
 730       break;
 731    case GL_INFO_LOG_LENGTH:
 732       *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
 733       break;
 734    case GL_SHADER_SOURCE_LENGTH:
 735       *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
 736       break;
 737    default:
 738       _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
 739       return;
 740    }
 741 }
 742
 743
 744 static void
 745 get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,
 746                      GLsizei *length, GLchar *infoLog)
 747 {
 748    struct gl_shader_program *shProg
 749       = _mesa_lookup_shader_program(ctx, program);
 750    if (!shProg) {
 751       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
 752       return;
 753    }
 754    _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);
 755 }
 756
 757
 758 static void
 759 get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,
 760                     GLsizei *length, GLchar *infoLog)
 761 {
 762    struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
 763    if (!sh) {
 764       _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
 765       return;
 766    }
 767    _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);
 768 }
 769
 770
 771 /**
 772  * Return shader source code.
 773  */
 774 static void
 775 get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,
 776                   GLsizei *length, GLchar *sourceOut)
 777 {
 778    struct gl_shader *sh;
 779    sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
 780    if (!sh) {
 781       return;
 782    }
 783    _mesa_copy_string(sourceOut, maxLength, length, sh->Source);
 784 }
 785
 786
 787 /**
 788  * Set/replace shader source code.  A helper function used by
 789  * glShaderSource[ARB] and glCreateShaderProgramEXT.
 790  */
 791 static void
 792 shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source)
 793 {
 794    struct gl_shader *sh;
 795
 796    sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");
 797    if (!sh)
 798       return;
 799
 800    /* free old shader source string and install new one */
 801    free((void *)sh->Source);
 802    sh->Source = source;
 803    sh->CompileStatus = GL_FALSE;
 804 #ifdef DEBUG
 805    sh->SourceChecksum = _mesa_str_checksum(sh->Source);
 806 #endif
 807 }
 808
 809
 810 /**
 811  * Compile a shader.
 812  */
 813 static void
 814 compile_shader(struct gl_context *ctx, GLuint shaderObj)
 815 {
 816    struct gl_shader *sh;
 817    struct gl_shader_compiler_options *options;
 818
 819    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
 820    if (!sh)
 821       return;
 822
 823    options = &ctx->ShaderCompilerOptions[sh->Stage];
 824
 825    /* set default pragma state for shader */
 826    sh->Pragmas = options->DefaultPragmas;
 827
 828    if (!sh->Source) {
 829       /* If the user called glCompileShader without first calling
 830        * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
 831        */
 832       sh->CompileStatus = GL_FALSE;
 833    } else {
 834       if (ctx->Shader.Flags & GLSL_DUMP) {
 835          printf("GLSL source for %s shader %d:\n",
 836                 _mesa_shader_stage_to_string(sh->Stage), sh->Name);
 837          printf("%s\n", sh->Source);
 838       }
 839
 840       /* this call will set the shader->CompileStatus field to indicate if
 841        * compilation was successful.
 842        */
 843       _mesa_glsl_compile_shader(ctx, sh, false, false);
 844
 845       if (ctx->Shader.Flags & GLSL_LOG) {
 846          _mesa_write_shader_to_file(sh);
 847       }
 848
 849       if (ctx->Shader.Flags & GLSL_DUMP) {
 850          if (sh->CompileStatus) {
 851             printf("GLSL IR for shader %d:\n", sh->Name);
 852             _mesa_print_ir(sh->ir, NULL);
 853             printf("\n\n");
 854          } else {
 855             printf("GLSL shader %d failed to compile.\n", sh->Name);
 856          }
 857          if (sh->InfoLog && sh->InfoLog[0] != 0) {
 858             printf("GLSL shader %d info log:\n", sh->Name);
 859             printf("%s\n", sh->InfoLog);
 860          }
 861       }
 862
 863    }
 864
 865    if (!sh->CompileStatus) {
 866       if (ctx->Shader.Flags & GLSL_DUMP_ON_ERROR) {
 867          fprintf(stderr, "GLSL source for %s shader %d:\n",
 868                  _mesa_shader_stage_to_string(sh->Stage), sh->Name);
 869          fprintf(stderr, "%s\n", sh->Source);
 870          fprintf(stderr, "Info Log:\n%s\n", sh->InfoLog);
 871          fflush(stderr);
 872       }
 873
 874       if (ctx->Shader.Flags & GLSL_REPORT_ERRORS) {
 875          _mesa_debug(ctx, "Error compiling shader %u:\n%s\n",
 876                      sh->Name, sh->InfoLog);
 877       }
 878    }
 879 }
 880
 881
 882 /**
 883  * Link a program's shaders.
 884  */
 885 static void
 886 link_program(struct gl_context *ctx, GLuint program)
 887 {
 888    struct gl_shader_program *shProg;
 889
 890    shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
 891    if (!shProg)
 892       return;
 893
 894    /* From the ARB_transform_feedback2 specification:
 895     * "The error INVALID_OPERATION is generated by LinkProgram if <program> is
 896     *  the name of a program being used by one or more transform feedback
 897     *  objects, even if the objects are not currently bound or are paused."
 898     */
 899    if (_mesa_transform_feedback_is_using_program(ctx, shProg)) {
 900       _mesa_error(ctx, GL_INVALID_OPERATION,
 901                   "glLinkProgram(transform feedback is using the program)");
 902       return;
 903    }
 904
 905    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 906
 907    _mesa_glsl_link_shader(ctx, shProg);
 908
 909    if (shProg->LinkStatus == GL_FALSE &&
 910        (ctx->Shader.Flags & GLSL_REPORT_ERRORS)) {
 911       _mesa_debug(ctx, "Error linking program %u:\n%s\n",
 912                   shProg->Name, shProg->InfoLog);
 913    }
 914
 915    /* debug code */
 916    if (0) {
 917       GLuint i;
 918
 919       printf("Link %u shaders in program %u: %s\n",
 920                    shProg->NumShaders, shProg->Name,
 921                    shProg->LinkStatus ? "Success" : "Failed");
 922
 923       for (i = 0; i < shProg->NumShaders; i++) {
 924          printf(" shader %u, type 0x%x\n",
 925                       shProg->Shaders[i]->Name,
 926                       shProg->Shaders[i]->Type);
 927       }
 928    }
 929 }
 930
 931
 932 /**
 933  * Print basic shader info (for debug).
 934  */
 935 static void
 936 print_shader_info(const struct gl_shader_program *shProg)
 937 {
 938    GLuint i;
 939
 940    printf("Mesa: glUseProgram(%u)\n", shProg->Name);
 941    for (i = 0; i < shProg->NumShaders; i++) {
 942       printf("  %s shader %u, checksum %u\n",
 943              _mesa_shader_stage_to_string(shProg->Shaders[i]->Stage),
 944              shProg->Shaders[i]->Name,
 945              shProg->Shaders[i]->SourceChecksum);
 946    }
 947    if (shProg->_LinkedShaders[MESA_SHADER_VERTEX])
 948       printf("  vert prog %u\n",
 949              shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program->Id);
 950    if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT])
 951       printf("  frag prog %u\n",
 952              shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program->Id);
 953    if (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY])
 954       printf("  geom prog %u\n",
 955              shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program->Id);
 956 }
 957
 958
 959 /**
 960  * Use the named shader program for subsequent glUniform calls
 961  */
 962 void
 963 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
 964                      const char *caller)
 965 {
 966    if ((shProg != NULL) && !shProg->LinkStatus) {
 967       _mesa_error(ctx, GL_INVALID_OPERATION,
 968                   "%s(program %u not linked)", caller, shProg->Name);
 969       return;
 970    }
 971
 972    if (ctx->Shader.ActiveProgram != shProg) {
 973       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
 974    }
 975 }
 976
 977 /**
 978  */
 979 static void
 980 use_shader_program(struct gl_context *ctx, GLenum type,
 981                    struct gl_shader_program *shProg)
 982 {
 983    struct gl_shader_program **target;
 984    gl_shader_stage stage = _mesa_shader_enum_to_shader_stage(type);
 985
 986    target = &ctx->Shader.CurrentProgram[stage];
 987    if ((shProg == NULL) || (shProg->_LinkedShaders[stage] == NULL))
 988       shProg = NULL;
 989
 990    if (*target != shProg) {
 991       FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
 992
 993       /* If the shader is also bound as the current rendering shader, unbind
 994        * it from that binding point as well.  This ensures that the correct
 995        * semantics of glDeleteProgram are maintained.
 996        */
 997       switch (type) {
 998       case GL_VERTEX_SHADER:
 999          /* Empty for now. */
1000          break;
1001       case GL_GEOMETRY_SHADER_ARB:
1002          /* Empty for now. */
1003          break;
1004       case GL_COMPUTE_SHADER:
1005          /* Empty for now. */
1006          break;
1007       case GL_FRAGMENT_SHADER:
1008          if (*target == ctx->Shader._CurrentFragmentProgram) {
1009             _mesa_reference_shader_program(ctx,
1010                                            &ctx->Shader._CurrentFragmentProgram,
1011                                            NULL);
1012          }
1013          break;
1014       }
1015
1016       _mesa_reference_shader_program(ctx, target, shProg);
1017       return;
1018    }
1019 }
1020
1021 /**
1022  * Use the named shader program for subsequent rendering.
1023  */
1024 void
1025 _mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
1026 {
1027    use_shader_program(ctx, GL_VERTEX_SHADER, shProg);
1028    use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);
1029    use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);
1030    use_shader_program(ctx, GL_COMPUTE_SHADER, shProg);
1031    _mesa_active_program(ctx, shProg, "glUseProgram");
1032
1033    if (ctx->Driver.UseProgram)
1034       ctx->Driver.UseProgram(ctx, shProg);
1035 }
1036
1037
1038 /**
1039  * Do validation of the given shader program.
1040  * \param errMsg  returns error message if validation fails.
1041  * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1042  */
1043 static GLboolean
1044 validate_shader_program(const struct gl_shader_program *shProg,
1045                         char *errMsg)
1046 {
1047    if (!shProg->LinkStatus) {
1048       return GL_FALSE;
1049    }
1050
1051    /* From the GL spec, a program is invalid if any of these are true:
1052
1053      any two active samplers in the current program object are of
1054      different types, but refer to the same texture image unit,
1055
1056      any active sampler in the current program object refers to a texture
1057      image unit where fixed-function fragment processing accesses a
1058      texture target that does not match the sampler type, or
1059
1060      the sum of the number of active samplers in the program and the
1061      number of texture image units enabled for fixed-function fragment
1062      processing exceeds the combined limit on the total number of texture
1063      image units allowed.
1064    */
1065
1066
1067    /*
1068     * Check: any two active samplers in the current program object are of
1069     * different types, but refer to the same texture image unit,
1070     */
1071    if (!_mesa_sampler_uniforms_are_valid(shProg, errMsg, 100))
1072       return GL_FALSE;
1073
1074    return GL_TRUE;
1075 }
1076
1077
1078 /**
1079  * Called via glValidateProgram()
1080  */
1081 static void
1082 validate_program(struct gl_context *ctx, GLuint program)
1083 {
1084    struct gl_shader_program *shProg;
1085    char errMsg[100] = "";
1086
1087    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1088    if (!shProg) {
1089       return;
1090    }
1091
1092    shProg->Validated = validate_shader_program(shProg, errMsg);
1093    if (!shProg->Validated) {
1094       /* update info log */
1095       if (shProg->InfoLog) {
1096          ralloc_free(shProg->InfoLog);
1097       }
1098       shProg->InfoLog = ralloc_strdup(shProg, errMsg);
1099    }
1100 }
1101
1102
1103
1104 void GLAPIENTRY
1105 _mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
1106 {
1107    GET_CURRENT_CONTEXT(ctx);
1108    attach_shader(ctx, program, shader);
1109 }
1110
1111
1112 void GLAPIENTRY
1113 _mesa_AttachShader(GLuint program, GLuint shader)
1114 {
1115    GET_CURRENT_CONTEXT(ctx);
1116    attach_shader(ctx, program, shader);
1117 }
1118
1119
1120 void GLAPIENTRY
1121 _mesa_CompileShader(GLhandleARB shaderObj)
1122 {
1123    GET_CURRENT_CONTEXT(ctx);
1124    if (MESA_VERBOSE & VERBOSE_API)
1125       _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
1126    compile_shader(ctx, shaderObj);
1127 }
1128
1129
1130 GLuint GLAPIENTRY
1131 _mesa_CreateShader(GLenum type)
1132 {
1133    GET_CURRENT_CONTEXT(ctx);
1134    if (MESA_VERBOSE & VERBOSE_API)
1135       _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));
1136    return create_shader(ctx, type);
1137 }
1138
1139
1140 GLhandleARB GLAPIENTRY
1141 _mesa_CreateShaderObjectARB(GLenum type)
1142 {
1143    GET_CURRENT_CONTEXT(ctx);
1144    return create_shader(ctx, type);
1145 }
1146
1147
1148 GLuint GLAPIENTRY
1149 _mesa_CreateProgram(void)
1150 {
1151    GET_CURRENT_CONTEXT(ctx);
1152    if (MESA_VERBOSE & VERBOSE_API)
1153       _mesa_debug(ctx, "glCreateProgram\n");
1154    return create_shader_program(ctx);
1155 }
1156
1157
1158 GLhandleARB GLAPIENTRY
1159 _mesa_CreateProgramObjectARB(void)
1160 {
1161    GET_CURRENT_CONTEXT(ctx);
1162    return create_shader_program(ctx);
1163 }
1164
1165
1166 void GLAPIENTRY
1167 _mesa_DeleteObjectARB(GLhandleARB obj)
1168 {
1169    if (MESA_VERBOSE & VERBOSE_API) {
1170       GET_CURRENT_CONTEXT(ctx);
1171       _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);
1172    }
1173
1174    if (obj) {
1175       GET_CURRENT_CONTEXT(ctx);
1176       FLUSH_VERTICES(ctx, 0);
1177       if (is_program(ctx, obj)) {
1178          delete_shader_program(ctx, obj);
1179       }
1180       else if (is_shader(ctx, obj)) {
1181          delete_shader(ctx, obj);
1182       }
1183       else {
1184          /* error? */
1185       }
1186    }
1187 }
1188
1189
1190 void GLAPIENTRY
1191 _mesa_DeleteProgram(GLuint name)
1192 {
1193    if (name) {
1194       GET_CURRENT_CONTEXT(ctx);
1195       FLUSH_VERTICES(ctx, 0);
1196       delete_shader_program(ctx, name);
1197    }
1198 }
1199
1200
1201 void GLAPIENTRY
1202 _mesa_DeleteShader(GLuint name)
1203 {
1204    if (name) {
1205       GET_CURRENT_CONTEXT(ctx);
1206       FLUSH_VERTICES(ctx, 0);
1207       delete_shader(ctx, name);
1208    }
1209 }
1210
1211
1212 void GLAPIENTRY
1213 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
1214 {
1215    GET_CURRENT_CONTEXT(ctx);
1216    detach_shader(ctx, program, shader);
1217 }
1218
1219
1220 void GLAPIENTRY
1221 _mesa_DetachShader(GLuint program, GLuint shader)
1222 {
1223    GET_CURRENT_CONTEXT(ctx);
1224    detach_shader(ctx, program, shader);
1225 }
1226
1227
1228 void GLAPIENTRY
1229 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
1230                             GLsizei * count, GLhandleARB * obj)
1231 {
1232    GET_CURRENT_CONTEXT(ctx);
1233    get_attached_shaders(ctx, container, maxCount, count, obj);
1234 }
1235
1236
1237 void GLAPIENTRY
1238 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
1239                          GLsizei *count, GLuint *obj)
1240 {
1241    GET_CURRENT_CONTEXT(ctx);
1242    get_attached_shaders(ctx, program, maxCount, count, obj);
1243 }
1244
1245
1246 void GLAPIENTRY
1247 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
1248                     GLcharARB * infoLog)
1249 {
1250    GET_CURRENT_CONTEXT(ctx);
1251    if (is_program(ctx, object)) {
1252       get_program_info_log(ctx, object, maxLength, length, infoLog);
1253    }
1254    else if (is_shader(ctx, object)) {
1255       get_shader_info_log(ctx, object, maxLength, length, infoLog);
1256    }
1257    else {
1258       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1259    }
1260 }
1261
1262
1263 void GLAPIENTRY
1264 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
1265 {
1266    GET_CURRENT_CONTEXT(ctx);
1267    /* Implement in terms of GetProgramiv, GetShaderiv */
1268    if (is_program(ctx, object)) {
1269       if (pname == GL_OBJECT_TYPE_ARB) {
1270          *params = GL_PROGRAM_OBJECT_ARB;
1271       }
1272       else {
1273          get_programiv(ctx, object, pname, params);
1274       }
1275    }
1276    else if (is_shader(ctx, object)) {
1277       if (pname == GL_OBJECT_TYPE_ARB) {
1278          *params = GL_SHADER_OBJECT_ARB;
1279       }
1280       else {
1281          get_shaderiv(ctx, object, pname, params);
1282       }
1283    }
1284    else {
1285       _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1286    }
1287 }
1288
1289
1290 void GLAPIENTRY
1291 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
1292                               GLfloat *params)
1293 {
1294    GLint iparams[1];  /* XXX is one element enough? */
1295    _mesa_GetObjectParameterivARB(object, pname, iparams);
1296    params[0] = (GLfloat) iparams[0];
1297 }
1298
1299
1300 void GLAPIENTRY
1301 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
1302 {
1303    GET_CURRENT_CONTEXT(ctx);
1304    get_programiv(ctx, program, pname, params);
1305 }
1306
1307
1308 void GLAPIENTRY
1309 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
1310 {
1311    GET_CURRENT_CONTEXT(ctx);
1312    get_shaderiv(ctx, shader, pname, params);
1313 }
1314
1315
1316 void GLAPIENTRY
1317 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
1318                         GLsizei *length, GLchar *infoLog)
1319 {
1320    GET_CURRENT_CONTEXT(ctx);
1321    get_program_info_log(ctx, program, bufSize, length, infoLog);
1322 }
1323
1324
1325 void GLAPIENTRY
1326 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
1327                        GLsizei *length, GLchar *infoLog)
1328 {
1329    GET_CURRENT_CONTEXT(ctx);
1330    get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1331 }
1332
1333
1334 void GLAPIENTRY
1335 _mesa_GetShaderSource(GLhandleARB shader, GLsizei maxLength,
1336                          GLsizei *length, GLcharARB *sourceOut)
1337 {
1338    GET_CURRENT_CONTEXT(ctx);
1339    get_shader_source(ctx, shader, maxLength, length, sourceOut);
1340 }
1341
1342
1343 GLhandleARB GLAPIENTRY
1344 _mesa_GetHandleARB(GLenum pname)
1345 {
1346    GET_CURRENT_CONTEXT(ctx);
1347    return get_handle(ctx, pname);
1348 }
1349
1350
1351 GLboolean GLAPIENTRY
1352 _mesa_IsProgram(GLuint name)
1353 {
1354    GET_CURRENT_CONTEXT(ctx);
1355    return is_program(ctx, name);
1356 }
1357
1358
1359 GLboolean GLAPIENTRY
1360 _mesa_IsShader(GLuint name)
1361 {
1362    GET_CURRENT_CONTEXT(ctx);
1363    return is_shader(ctx, name);
1364 }
1365
1366
1367 void GLAPIENTRY
1368 _mesa_LinkProgram(GLhandleARB programObj)
1369 {
1370    GET_CURRENT_CONTEXT(ctx);
1371    link_program(ctx, programObj);
1372 }
1373
1374
1375
1376 /**
1377  * Read shader source code from a file.
1378  * Useful for debugging to override an app's shader.
1379  */
1380 static GLcharARB *
1381 read_shader(const char *fname)
1382 {
1383    const int max = 50*1000;
1384    FILE *f = fopen(fname, "r");
1385    GLcharARB *buffer, *shader;
1386    int len;
1387
1388    if (!f) {
1389       return NULL;
1390    }
1391
1392    buffer = malloc(max);
1393    len = fread(buffer, 1, max, f);
1394    buffer[len] = 0;
1395
1396    fclose(f);
1397
1398    shader = _mesa_strdup(buffer);
1399    free(buffer);
1400
1401    return shader;
1402 }
1403
1404
1405 /**
1406  * Called via glShaderSource() and glShaderSourceARB() API functions.
1407  * Basically, concatenate the source code strings into one long string
1408  * and pass it to _mesa_shader_source().
1409  */
1410 void GLAPIENTRY
1411 _mesa_ShaderSource(GLhandleARB shaderObj, GLsizei count,
1412                       const GLcharARB * const * string, const GLint * length)
1413 {
1414    GET_CURRENT_CONTEXT(ctx);
1415    GLint *offsets;
1416    GLsizei i, totalLength;
1417    GLcharARB *source;
1418    GLuint checksum;
1419
1420    if (!shaderObj || string == NULL) {
1421       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1422       return;
1423    }
1424
1425    /*
1426     * This array holds offsets of where the appropriate string ends, thus the
1427     * last element will be set to the total length of the source code.
1428     */
1429    offsets = malloc(count * sizeof(GLint));
1430    if (offsets == NULL) {
1431       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1432       return;
1433    }
1434
1435    for (i = 0; i < count; i++) {
1436       if (string[i] == NULL) {
1437          free((GLvoid *) offsets);
1438          _mesa_error(ctx, GL_INVALID_OPERATION,
1439                      "glShaderSourceARB(null string)");
1440          return;
1441       }
1442       if (length == NULL || length[i] < 0)
1443          offsets[i] = strlen(string[i]);
1444       else
1445          offsets[i] = length[i];
1446       /* accumulate string lengths */
1447       if (i > 0)
1448          offsets[i] += offsets[i - 1];
1449    }
1450
1451    /* Total length of source string is sum off all strings plus two.
1452     * One extra byte for terminating zero, another extra byte to silence
1453     * valgrind warnings in the parser/grammer code.
1454     */
1455    totalLength = offsets[count - 1] + 2;
1456    source = malloc(totalLength * sizeof(GLcharARB));
1457    if (source == NULL) {
1458       free((GLvoid *) offsets);
1459       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1460       return;
1461    }
1462
1463    for (i = 0; i < count; i++) {
1464       GLint start = (i > 0) ? offsets[i - 1] : 0;
1465       memcpy(source + start, string[i],
1466              (offsets[i] - start) * sizeof(GLcharARB));
1467    }
1468    source[totalLength - 1] = '\0';
1469    source[totalLength - 2] = '\0';
1470
1471    if (SHADER_SUBST) {
1472       /* Compute the shader's source code checksum then try to open a file
1473        * named newshader_<CHECKSUM>.  If it exists, use it in place of the
1474        * original shader source code.  For debugging.
1475        */
1476       char filename[100];
1477       GLcharARB *newSource;
1478
1479       checksum = _mesa_str_checksum(source);
1480
1481       _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);
1482
1483       newSource = read_shader(filename);
1484       if (newSource) {
1485          fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
1486                        shaderObj, checksum, filename);
1487          free(source);
1488          source = newSource;
1489       }
1490    }
1491
1492    shader_source(ctx, shaderObj, source);
1493
1494    if (SHADER_SUBST) {
1495       struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
1496       if (sh)
1497          sh->SourceChecksum = checksum; /* save original checksum */
1498    }
1499
1500    free(offsets);
1501 }
1502
1503
1504 void GLAPIENTRY
1505 _mesa_UseProgram(GLhandleARB program)
1506 {
1507    GET_CURRENT_CONTEXT(ctx);
1508    struct gl_shader_program *shProg;
1509
1510    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1511       _mesa_error(ctx, GL_INVALID_OPERATION,
1512                   "glUseProgram(transform feedback active)");
1513       return;
1514    }
1515
1516    if (program) {
1517       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1518       if (!shProg) {
1519          return;
1520       }
1521       if (!shProg->LinkStatus) {
1522          _mesa_error(ctx, GL_INVALID_OPERATION,
1523                      "glUseProgram(program %u not linked)", program);
1524          return;
1525       }
1526
1527       /* debug code */
1528       if (ctx->Shader.Flags & GLSL_USE_PROG) {
1529          print_shader_info(shProg);
1530       }
1531    }
1532    else {
1533       shProg = NULL;
1534    }
1535
1536    _mesa_use_program(ctx, shProg);
1537 }
1538
1539
1540 void GLAPIENTRY
1541 _mesa_ValidateProgram(GLhandleARB program)
1542 {
1543    GET_CURRENT_CONTEXT(ctx);
1544    validate_program(ctx, program);
1545 }
1546
1547
1548 /**
1549  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1550  */
1551 void GLAPIENTRY
1552 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1553                                GLint* range, GLint* precision)
1554 {
1555    const struct gl_program_constants *limits;
1556    const struct gl_precision *p;
1557    GET_CURRENT_CONTEXT(ctx);
1558
1559    switch (shadertype) {
1560    case GL_VERTEX_SHADER:
1561       limits = &ctx->Const.Program[MESA_SHADER_VERTEX];
1562       break;
1563    case GL_FRAGMENT_SHADER:
1564       limits = &ctx->Const.Program[MESA_SHADER_FRAGMENT];
1565       break;
1566    default:
1567       _mesa_error(ctx, GL_INVALID_ENUM,
1568                   "glGetShaderPrecisionFormat(shadertype)");
1569       return;
1570    }
1571
1572    switch (precisiontype) {
1573    case GL_LOW_FLOAT:
1574       p = &limits->LowFloat;
1575       break;
1576    case GL_MEDIUM_FLOAT:
1577       p = &limits->MediumFloat;
1578       break;
1579    case GL_HIGH_FLOAT:
1580       p = &limits->HighFloat;
1581       break;
1582    case GL_LOW_INT:
1583       p = &limits->LowInt;
1584       break;
1585    case GL_MEDIUM_INT:
1586       p = &limits->MediumInt;
1587       break;
1588    case GL_HIGH_INT:
1589       p = &limits->HighInt;
1590       break;
1591    default:
1592       _mesa_error(ctx, GL_INVALID_ENUM,
1593                   "glGetShaderPrecisionFormat(precisiontype)");
1594       return;
1595    }
1596
1597    range[0] = p->RangeMin;
1598    range[1] = p->RangeMax;
1599    precision[0] = p->Precision;
1600 }
1601
1602
1603 /**
1604  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1605  */
1606 void GLAPIENTRY
1607 _mesa_ReleaseShaderCompiler(void)
1608 {
1609    _mesa_destroy_shader_compiler_caches();
1610 }
1611
1612
1613 /**
1614  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1615  */
1616 void GLAPIENTRY
1617 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1618                    const void* binary, GLint length)
1619 {
1620    GET_CURRENT_CONTEXT(ctx);
1621    (void) n;
1622    (void) shaders;
1623    (void) binaryformat;
1624    (void) binary;
1625    (void) length;
1626    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1627 }
1628
1629
1630 void GLAPIENTRY
1631 _mesa_GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
1632                        GLenum *binaryFormat, GLvoid *binary)
1633 {
1634    struct gl_shader_program *shProg;
1635    GET_CURRENT_CONTEXT(ctx);
1636
1637    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetProgramBinary");
1638    if (!shProg)
1639       return;
1640
1641    if (!shProg->LinkStatus) {
1642       _mesa_error(ctx, GL_INVALID_OPERATION,
1643                   "glGetProgramBinary(program %u not linked)",
1644                   shProg->Name);
1645       return;
1646    }
1647
1648    if (bufSize < 0){
1649       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramBinary(bufSize < 0)");
1650       return;
1651    }
1652
1653    /* The ARB_get_program_binary spec says:
1654     *
1655     *     "If <length> is NULL, then no length is returned."
1656     */
1657    if (length != NULL)
1658       *length = 0;
1659
1660    (void) binaryFormat;
1661    (void) binary;
1662 }
1663
1664 void GLAPIENTRY
1665 _mesa_ProgramBinary(GLuint program, GLenum binaryFormat,
1666                     const GLvoid *binary, GLsizei length)
1667 {
1668    struct gl_shader_program *shProg;
1669    GET_CURRENT_CONTEXT(ctx);
1670
1671    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramBinary");
1672    if (!shProg)
1673       return;
1674
1675    (void) binaryFormat;
1676    (void) binary;
1677    (void) length;
1678    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1679 }
1680
1681
1682 void GLAPIENTRY
1683 _mesa_ProgramParameteri(GLuint program, GLenum pname, GLint value)
1684 {
1685    struct gl_shader_program *shProg;
1686    GET_CURRENT_CONTEXT(ctx);
1687
1688    shProg = _mesa_lookup_shader_program_err(ctx, program,
1689                                             "glProgramParameteri");
1690    if (!shProg)
1691       return;
1692
1693    switch (pname) {
1694    case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
1695       /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
1696        * is part of OpenGL ES 3.0.  For the ES2 case, this function shouldn't
1697        * even be in the dispatch table, so we shouldn't need to expclicitly
1698        * check here.
1699        *
1700        * On desktop, we ignore the 3.0+ requirement because it is silly.
1701        */
1702
1703       /* The ARB_get_program_binary extension spec says:
1704        *
1705        *     "An INVALID_VALUE error is generated if the <value> argument to
1706        *     ProgramParameteri is not TRUE or FALSE."
1707        */
1708       if (value != GL_TRUE && value != GL_FALSE) {
1709          _mesa_error(ctx, GL_INVALID_VALUE,
1710                      "glProgramParameteri(pname=%s, value=%d): "
1711                      "value must be 0 or 1.",
1712                      _mesa_lookup_enum_by_nr(pname),
1713                      value);
1714          return;
1715       }
1716
1717       /* No need to notify the driver.  Any changes will actually take effect
1718        * the next time the shader is linked.
1719        *
1720        * The ARB_get_program_binary extension spec says:
1721        *
1722        *     "To indicate that a program binary is likely to be retrieved,
1723        *     ProgramParameteri should be called with <pname>
1724        *     PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
1725        *     will not be in effect until the next time LinkProgram or
1726        *     ProgramBinary has been called successfully."
1727        *
1728        * The resloution of issue 9 in the extension spec also says:
1729        *
1730        *     "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
1731        *     to indicate to the GL implementation that this program will
1732        *     likely be saved with GetProgramBinary at some point. This will
1733        *     give the GL implementation the opportunity to track any state
1734        *     changes made to the program before being saved such that when it
1735        *     is loaded again a recompile can be avoided."
1736        */
1737       shProg->BinaryRetreivableHint = value;
1738       return;
1739    default:
1740       break;
1741    }
1742
1743    _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteri(pname=%s)",
1744                _mesa_lookup_enum_by_nr(pname));
1745 }
1746
1747 void
1748 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
1749                          struct gl_shader_program *shProg)
1750 {
1751    use_shader_program(ctx, type, shProg);
1752
1753    if (ctx->Driver.UseProgram)
1754       ctx->Driver.UseProgram(ctx, shProg);
1755 }
1756
1757
1758 /**
1759  * For GL_EXT_separate_shader_objects
1760  */
1761 void GLAPIENTRY
1762 _mesa_UseShaderProgramEXT(GLenum type, GLuint program)
1763 {
1764    GET_CURRENT_CONTEXT(ctx);
1765    struct gl_shader_program *shProg = NULL;
1766
1767    if (!_mesa_validate_shader_target(ctx, type)) {
1768       _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");
1769       return;
1770    }
1771
1772    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1773       _mesa_error(ctx, GL_INVALID_OPERATION,
1774                   "glUseShaderProgramEXT(transform feedback is active)");
1775       return;
1776    }
1777
1778    if (program) {
1779       shProg = _mesa_lookup_shader_program_err(ctx, program,
1780                                                "glUseShaderProgramEXT");
1781       if (shProg == NULL)
1782          return;
1783
1784       if (!shProg->LinkStatus) {
1785          _mesa_error(ctx, GL_INVALID_OPERATION,
1786                      "glUseShaderProgramEXT(program not linked)");
1787          return;
1788       }
1789    }
1790
1791    _mesa_use_shader_program(ctx, type, shProg);
1792 }
1793
1794
1795 /**
1796  * For GL_EXT_separate_shader_objects
1797  */
1798 void GLAPIENTRY
1799 _mesa_ActiveProgramEXT(GLuint program)
1800 {
1801    GET_CURRENT_CONTEXT(ctx);
1802    struct gl_shader_program *shProg = (program != 0)
1803       ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")
1804       : NULL;
1805
1806    _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
1807    return;
1808 }
1809
1810
1811 /**
1812  * For GL_EXT_separate_shader_objects
1813  */
1814 GLuint GLAPIENTRY
1815 _mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)
1816 {
1817    GET_CURRENT_CONTEXT(ctx);
1818    const GLuint shader = create_shader(ctx, type);
1819    GLuint program = 0;
1820
1821    if (shader) {
1822       shader_source(ctx, shader, _mesa_strdup(string));
1823       compile_shader(ctx, shader);
1824
1825       program = create_shader_program(ctx);
1826       if (program) {
1827          struct gl_shader_program *shProg;
1828          struct gl_shader *sh;
1829          GLint compiled = GL_FALSE;
1830
1831          shProg = _mesa_lookup_shader_program(ctx, program);
1832          sh = _mesa_lookup_shader(ctx, shader);
1833
1834          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
1835          if (compiled) {
1836             attach_shader(ctx, program, shader);
1837             link_program(ctx, program);
1838             detach_shader(ctx, program, shader);
1839
1840 #if 0
1841             /* Possibly... */
1842             if (active-user-defined-varyings-in-linked-program) {
1843                append-error-to-info-log;
1844                shProg->LinkStatus = GL_FALSE;
1845             }
1846 #endif
1847          }
1848
1849          ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
1850       }
1851
1852       delete_shader(ctx, shader);
1853    }
1854
1855    return program;
1856 }
1857
1858
1859 /**
1860  * Copy program-specific data generated by linking from the gl_shader_program
1861  * object to a specific gl_program object.
1862  */
1863 void
1864 _mesa_copy_linked_program_data(gl_shader_stage type,
1865                                const struct gl_shader_program *src,
1866                                struct gl_program *dst)
1867 {
1868    switch (type) {
1869    case MESA_SHADER_VERTEX:
1870       dst->UsesClipDistanceOut = src->Vert.UsesClipDistance;
1871       break;
1872    case MESA_SHADER_GEOMETRY: {
1873       struct gl_geometry_program *dst_gp = (struct gl_geometry_program *) dst;
1874       dst_gp->VerticesIn = src->Geom.VerticesIn;
1875       dst_gp->VerticesOut = src->Geom.VerticesOut;
1876       dst_gp->Invocations = src->Geom.Invocations;
1877       dst_gp->InputType = src->Geom.InputType;
1878       dst_gp->OutputType = src->Geom.OutputType;
1879       dst->UsesClipDistanceOut = src->Geom.UsesClipDistance;
1880       dst_gp->UsesEndPrimitive = src->Geom.UsesEndPrimitive;
1881    }
1882       break;
1883    case MESA_SHADER_COMPUTE: {
1884       struct gl_compute_program *dst_cp = (struct gl_compute_program *) dst;
1885       int i;
1886       for (i = 0; i < 3; i++)
1887          dst_cp->LocalSize[i] = src->Comp.LocalSize[i];
1888    }
1889       break;
1890    default:
1891       break;
1892    }
1893 }
1894
1895
1896 /**
1897  * ARB_separate_shader_objects: Compile & Link Program
1898  */
1899 GLuint GLAPIENTRY
1900 _mesa_CreateShaderProgramv(GLenum type, GLsizei count,
1901                            const GLchar* const *strings)
1902 {
1903    return 0;
1904 }