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    case GL_PROGRAM_SEPARABLE:
 700       if (!ctx->Extensions.ARB_separate_shader_objects)
 701          break;
 702
 703       *params = shProg->SeparateShader;
 704       return;
 705    default:
 706       break;
 707    }
 708
 709    _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname=%s)",
 710                _mesa_lookup_enum_by_nr(pname));
 711 }
 712
 713
 714 /**
 715  * glGetShaderiv() - get GLSL shader state
 716  */
 717 static void
 718 get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)
 719 {
 720    struct gl_shader *shader =
 721       _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");
 722
 723    if (!shader) {
 724       return;
 725    }
 726
 727    switch (pname) {
 728    case GL_SHADER_TYPE:
 729       *params = shader->Type;
 730       break;
 731    case GL_DELETE_STATUS:
 732       *params = shader->DeletePending;
 733       break;
 734    case GL_COMPILE_STATUS:
 735       *params = shader->CompileStatus;
 736       break;
 737    case GL_INFO_LOG_LENGTH:
 738       *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
 739       break;
 740    case GL_SHADER_SOURCE_LENGTH:
 741       *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
 742       break;
 743    default:
 744       _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
 745       return;
 746    }
 747 }
 748
 749
 750 static void
 751 get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,
 752                      GLsizei *length, GLchar *infoLog)
 753 {
 754    struct gl_shader_program *shProg
 755       = _mesa_lookup_shader_program(ctx, program);
 756    if (!shProg) {
 757       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
 758       return;
 759    }
 760    _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);
 761 }
 762
 763
 764 static void
 765 get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,
 766                     GLsizei *length, GLchar *infoLog)
 767 {
 768    struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
 769    if (!sh) {
 770       _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
 771       return;
 772    }
 773    _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);
 774 }
 775
 776
 777 /**
 778  * Return shader source code.
 779  */
 780 static void
 781 get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,
 782                   GLsizei *length, GLchar *sourceOut)
 783 {
 784    struct gl_shader *sh;
 785    sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
 786    if (!sh) {
 787       return;
 788    }
 789    _mesa_copy_string(sourceOut, maxLength, length, sh->Source);
 790 }
 791
 792
 793 /**
 794  * Set/replace shader source code.  A helper function used by
 795  * glShaderSource[ARB] and glCreateShaderProgramEXT.
 796  */
 797 static void
 798 shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source)
 799 {
 800    struct gl_shader *sh;
 801
 802    sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");
 803    if (!sh)
 804       return;
 805
 806    /* free old shader source string and install new one */
 807    free((void *)sh->Source);
 808    sh->Source = source;
 809    sh->CompileStatus = GL_FALSE;
 810 #ifdef DEBUG
 811    sh->SourceChecksum = _mesa_str_checksum(sh->Source);
 812 #endif
 813 }
 814
 815
 816 /**
 817  * Compile a shader.
 818  */
 819 static void
 820 compile_shader(struct gl_context *ctx, GLuint shaderObj)
 821 {
 822    struct gl_shader *sh;
 823    struct gl_shader_compiler_options *options;
 824
 825    sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
 826    if (!sh)
 827       return;
 828
 829    options = &ctx->ShaderCompilerOptions[sh->Stage];
 830
 831    /* set default pragma state for shader */
 832    sh->Pragmas = options->DefaultPragmas;
 833
 834    if (!sh->Source) {
 835       /* If the user called glCompileShader without first calling
 836        * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
 837        */
 838       sh->CompileStatus = GL_FALSE;
 839    } else {
 840       if (ctx->Shader.Flags & GLSL_DUMP) {
 841          printf("GLSL source for %s shader %d:\n",
 842                 _mesa_shader_stage_to_string(sh->Stage), sh->Name);
 843          printf("%s\n", sh->Source);
 844       }
 845
 846       /* this call will set the shader->CompileStatus field to indicate if
 847        * compilation was successful.
 848        */
 849       _mesa_glsl_compile_shader(ctx, sh, false, false);
 850
 851       if (ctx->Shader.Flags & GLSL_LOG) {
 852          _mesa_write_shader_to_file(sh);
 853       }
 854
 855       if (ctx->Shader.Flags & GLSL_DUMP) {
 856          if (sh->CompileStatus) {
 857             printf("GLSL IR for shader %d:\n", sh->Name);
 858             _mesa_print_ir(sh->ir, NULL);
 859             printf("\n\n");
 860          } else {
 861             printf("GLSL shader %d failed to compile.\n", sh->Name);
 862          }
 863          if (sh->InfoLog && sh->InfoLog[0] != 0) {
 864             printf("GLSL shader %d info log:\n", sh->Name);
 865             printf("%s\n", sh->InfoLog);
 866          }
 867       }
 868
 869    }
 870
 871    if (!sh->CompileStatus) {
 872       if (ctx->Shader.Flags & GLSL_DUMP_ON_ERROR) {
 873          fprintf(stderr, "GLSL source for %s shader %d:\n",
 874                  _mesa_shader_stage_to_string(sh->Stage), sh->Name);
 875          fprintf(stderr, "%s\n", sh->Source);
 876          fprintf(stderr, "Info Log:\n%s\n", sh->InfoLog);
 877          fflush(stderr);
 878       }
 879
 880       if (ctx->Shader.Flags & GLSL_REPORT_ERRORS) {
 881          _mesa_debug(ctx, "Error compiling shader %u:\n%s\n",
 882                      sh->Name, sh->InfoLog);
 883       }
 884    }
 885 }
 886
 887
 888 /**
 889  * Link a program's shaders.
 890  */
 891 static void
 892 link_program(struct gl_context *ctx, GLuint program)
 893 {
 894    struct gl_shader_program *shProg;
 895
 896    shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
 897    if (!shProg)
 898       return;
 899
 900    /* From the ARB_transform_feedback2 specification:
 901     * "The error INVALID_OPERATION is generated by LinkProgram if <program> is
 902     *  the name of a program being used by one or more transform feedback
 903     *  objects, even if the objects are not currently bound or are paused."
 904     */
 905    if (_mesa_transform_feedback_is_using_program(ctx, shProg)) {
 906       _mesa_error(ctx, GL_INVALID_OPERATION,
 907                   "glLinkProgram(transform feedback is using the program)");
 908       return;
 909    }
 910
 911    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 912
 913    _mesa_glsl_link_shader(ctx, shProg);
 914
 915    if (shProg->LinkStatus == GL_FALSE &&
 916        (ctx->Shader.Flags & GLSL_REPORT_ERRORS)) {
 917       _mesa_debug(ctx, "Error linking program %u:\n%s\n",
 918                   shProg->Name, shProg->InfoLog);
 919    }
 920
 921    /* debug code */
 922    if (0) {
 923       GLuint i;
 924
 925       printf("Link %u shaders in program %u: %s\n",
 926                    shProg->NumShaders, shProg->Name,
 927                    shProg->LinkStatus ? "Success" : "Failed");
 928
 929       for (i = 0; i < shProg->NumShaders; i++) {
 930          printf(" shader %u, type 0x%x\n",
 931                       shProg->Shaders[i]->Name,
 932                       shProg->Shaders[i]->Type);
 933       }
 934    }
 935 }
 936
 937
 938 /**
 939  * Print basic shader info (for debug).
 940  */
 941 static void
 942 print_shader_info(const struct gl_shader_program *shProg)
 943 {
 944    GLuint i;
 945
 946    printf("Mesa: glUseProgram(%u)\n", shProg->Name);
 947    for (i = 0; i < shProg->NumShaders; i++) {
 948       printf("  %s shader %u, checksum %u\n",
 949              _mesa_shader_stage_to_string(shProg->Shaders[i]->Stage),
 950              shProg->Shaders[i]->Name,
 951              shProg->Shaders[i]->SourceChecksum);
 952    }
 953    if (shProg->_LinkedShaders[MESA_SHADER_VERTEX])
 954       printf("  vert prog %u\n",
 955              shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program->Id);
 956    if (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT])
 957       printf("  frag prog %u\n",
 958              shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program->Id);
 959    if (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY])
 960       printf("  geom prog %u\n",
 961              shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program->Id);
 962 }
 963
 964
 965 /**
 966  * Use the named shader program for subsequent glUniform calls
 967  */
 968 void
 969 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
 970                      const char *caller)
 971 {
 972    if ((shProg != NULL) && !shProg->LinkStatus) {
 973       _mesa_error(ctx, GL_INVALID_OPERATION,
 974                   "%s(program %u not linked)", caller, shProg->Name);
 975       return;
 976    }
 977
 978    if (ctx->Shader.ActiveProgram != shProg) {
 979       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
 980    }
 981 }
 982
 983 /**
 984  */
 985 static void
 986 use_shader_program(struct gl_context *ctx, GLenum type,
 987                    struct gl_shader_program *shProg)
 988 {
 989    struct gl_shader_program **target;
 990    gl_shader_stage stage = _mesa_shader_enum_to_shader_stage(type);
 991
 992    target = &ctx->Shader.CurrentProgram[stage];
 993    if ((shProg == NULL) || (shProg->_LinkedShaders[stage] == NULL))
 994       shProg = NULL;
 995
 996    if (*target != shProg) {
 997       FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
 998
 999       /* If the shader is also bound as the current rendering shader, unbind
1000        * it from that binding point as well.  This ensures that the correct
1001        * semantics of glDeleteProgram are maintained.
1002        */
1003       switch (type) {
1004       case GL_VERTEX_SHADER:
1005          /* Empty for now. */
1006          break;
1007       case GL_GEOMETRY_SHADER_ARB:
1008          /* Empty for now. */
1009          break;
1010       case GL_COMPUTE_SHADER:
1011          /* Empty for now. */
1012          break;
1013       case GL_FRAGMENT_SHADER:
1014          if (*target == ctx->Shader._CurrentFragmentProgram) {
1015             _mesa_reference_shader_program(ctx,
1016                                            &ctx->Shader._CurrentFragmentProgram,
1017                                            NULL);
1018          }
1019          break;
1020       }
1021
1022       _mesa_reference_shader_program(ctx, target, shProg);
1023       return;
1024    }
1025 }
1026
1027 /**
1028  * Use the named shader program for subsequent rendering.
1029  */
1030 void
1031 _mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
1032 {
1033    use_shader_program(ctx, GL_VERTEX_SHADER, shProg);
1034    use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);
1035    use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);
1036    use_shader_program(ctx, GL_COMPUTE_SHADER, shProg);
1037    _mesa_active_program(ctx, shProg, "glUseProgram");
1038
1039    if (ctx->Driver.UseProgram)
1040       ctx->Driver.UseProgram(ctx, shProg);
1041 }
1042
1043
1044 /**
1045  * Do validation of the given shader program.
1046  * \param errMsg  returns error message if validation fails.
1047  * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1048  */
1049 static GLboolean
1050 validate_shader_program(const struct gl_shader_program *shProg,
1051                         char *errMsg)
1052 {
1053    if (!shProg->LinkStatus) {
1054       return GL_FALSE;
1055    }
1056
1057    /* From the GL spec, a program is invalid if any of these are true:
1058
1059      any two active samplers in the current program object are of
1060      different types, but refer to the same texture image unit,
1061
1062      any active sampler in the current program object refers to a texture
1063      image unit where fixed-function fragment processing accesses a
1064      texture target that does not match the sampler type, or
1065
1066      the sum of the number of active samplers in the program and the
1067      number of texture image units enabled for fixed-function fragment
1068      processing exceeds the combined limit on the total number of texture
1069      image units allowed.
1070    */
1071
1072
1073    /*
1074     * Check: any two active samplers in the current program object are of
1075     * different types, but refer to the same texture image unit,
1076     */
1077    if (!_mesa_sampler_uniforms_are_valid(shProg, errMsg, 100))
1078       return GL_FALSE;
1079
1080    return GL_TRUE;
1081 }
1082
1083
1084 /**
1085  * Called via glValidateProgram()
1086  */
1087 static void
1088 validate_program(struct gl_context *ctx, GLuint program)
1089 {
1090    struct gl_shader_program *shProg;
1091    char errMsg[100] = "";
1092
1093    shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1094    if (!shProg) {
1095       return;
1096    }
1097
1098    shProg->Validated = validate_shader_program(shProg, errMsg);
1099    if (!shProg->Validated) {
1100       /* update info log */
1101       if (shProg->InfoLog) {
1102          ralloc_free(shProg->InfoLog);
1103       }
1104       shProg->InfoLog = ralloc_strdup(shProg, errMsg);
1105    }
1106 }
1107
1108
1109
1110 void GLAPIENTRY
1111 _mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
1112 {
1113    GET_CURRENT_CONTEXT(ctx);
1114    attach_shader(ctx, program, shader);
1115 }
1116
1117
1118 void GLAPIENTRY
1119 _mesa_AttachShader(GLuint program, GLuint shader)
1120 {
1121    GET_CURRENT_CONTEXT(ctx);
1122    attach_shader(ctx, program, shader);
1123 }
1124
1125
1126 void GLAPIENTRY
1127 _mesa_CompileShader(GLhandleARB shaderObj)
1128 {
1129    GET_CURRENT_CONTEXT(ctx);
1130    if (MESA_VERBOSE & VERBOSE_API)
1131       _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
1132    compile_shader(ctx, shaderObj);
1133 }
1134
1135
1136 GLuint GLAPIENTRY
1137 _mesa_CreateShader(GLenum type)
1138 {
1139    GET_CURRENT_CONTEXT(ctx);
1140    if (MESA_VERBOSE & VERBOSE_API)
1141       _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));
1142    return create_shader(ctx, type);
1143 }
1144
1145
1146 GLhandleARB GLAPIENTRY
1147 _mesa_CreateShaderObjectARB(GLenum type)
1148 {
1149    GET_CURRENT_CONTEXT(ctx);
1150    return create_shader(ctx, type);
1151 }
1152
1153
1154 GLuint GLAPIENTRY
1155 _mesa_CreateProgram(void)
1156 {
1157    GET_CURRENT_CONTEXT(ctx);
1158    if (MESA_VERBOSE & VERBOSE_API)
1159       _mesa_debug(ctx, "glCreateProgram\n");
1160    return create_shader_program(ctx);
1161 }
1162
1163
1164 GLhandleARB GLAPIENTRY
1165 _mesa_CreateProgramObjectARB(void)
1166 {
1167    GET_CURRENT_CONTEXT(ctx);
1168    return create_shader_program(ctx);
1169 }
1170
1171
1172 void GLAPIENTRY
1173 _mesa_DeleteObjectARB(GLhandleARB obj)
1174 {
1175    if (MESA_VERBOSE & VERBOSE_API) {
1176       GET_CURRENT_CONTEXT(ctx);
1177       _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);
1178    }
1179
1180    if (obj) {
1181       GET_CURRENT_CONTEXT(ctx);
1182       FLUSH_VERTICES(ctx, 0);
1183       if (is_program(ctx, obj)) {
1184          delete_shader_program(ctx, obj);
1185       }
1186       else if (is_shader(ctx, obj)) {
1187          delete_shader(ctx, obj);
1188       }
1189       else {
1190          /* error? */
1191       }
1192    }
1193 }
1194
1195
1196 void GLAPIENTRY
1197 _mesa_DeleteProgram(GLuint name)
1198 {
1199    if (name) {
1200       GET_CURRENT_CONTEXT(ctx);
1201       FLUSH_VERTICES(ctx, 0);
1202       delete_shader_program(ctx, name);
1203    }
1204 }
1205
1206
1207 void GLAPIENTRY
1208 _mesa_DeleteShader(GLuint name)
1209 {
1210    if (name) {
1211       GET_CURRENT_CONTEXT(ctx);
1212       FLUSH_VERTICES(ctx, 0);
1213       delete_shader(ctx, name);
1214    }
1215 }
1216
1217
1218 void GLAPIENTRY
1219 _mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
1220 {
1221    GET_CURRENT_CONTEXT(ctx);
1222    detach_shader(ctx, program, shader);
1223 }
1224
1225
1226 void GLAPIENTRY
1227 _mesa_DetachShader(GLuint program, GLuint shader)
1228 {
1229    GET_CURRENT_CONTEXT(ctx);
1230    detach_shader(ctx, program, shader);
1231 }
1232
1233
1234 void GLAPIENTRY
1235 _mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
1236                             GLsizei * count, GLhandleARB * obj)
1237 {
1238    GET_CURRENT_CONTEXT(ctx);
1239    get_attached_shaders(ctx, container, maxCount, count, obj);
1240 }
1241
1242
1243 void GLAPIENTRY
1244 _mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
1245                          GLsizei *count, GLuint *obj)
1246 {
1247    GET_CURRENT_CONTEXT(ctx);
1248    get_attached_shaders(ctx, program, maxCount, count, obj);
1249 }
1250
1251
1252 void GLAPIENTRY
1253 _mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
1254                     GLcharARB * infoLog)
1255 {
1256    GET_CURRENT_CONTEXT(ctx);
1257    if (is_program(ctx, object)) {
1258       get_program_info_log(ctx, object, maxLength, length, infoLog);
1259    }
1260    else if (is_shader(ctx, object)) {
1261       get_shader_info_log(ctx, object, maxLength, length, infoLog);
1262    }
1263    else {
1264       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1265    }
1266 }
1267
1268
1269 void GLAPIENTRY
1270 _mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
1271 {
1272    GET_CURRENT_CONTEXT(ctx);
1273    /* Implement in terms of GetProgramiv, GetShaderiv */
1274    if (is_program(ctx, object)) {
1275       if (pname == GL_OBJECT_TYPE_ARB) {
1276          *params = GL_PROGRAM_OBJECT_ARB;
1277       }
1278       else {
1279          get_programiv(ctx, object, pname, params);
1280       }
1281    }
1282    else if (is_shader(ctx, object)) {
1283       if (pname == GL_OBJECT_TYPE_ARB) {
1284          *params = GL_SHADER_OBJECT_ARB;
1285       }
1286       else {
1287          get_shaderiv(ctx, object, pname, params);
1288       }
1289    }
1290    else {
1291       _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1292    }
1293 }
1294
1295
1296 void GLAPIENTRY
1297 _mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
1298                               GLfloat *params)
1299 {
1300    GLint iparams[1];  /* XXX is one element enough? */
1301    _mesa_GetObjectParameterivARB(object, pname, iparams);
1302    params[0] = (GLfloat) iparams[0];
1303 }
1304
1305
1306 void GLAPIENTRY
1307 _mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
1308 {
1309    GET_CURRENT_CONTEXT(ctx);
1310    get_programiv(ctx, program, pname, params);
1311 }
1312
1313
1314 void GLAPIENTRY
1315 _mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
1316 {
1317    GET_CURRENT_CONTEXT(ctx);
1318    get_shaderiv(ctx, shader, pname, params);
1319 }
1320
1321
1322 void GLAPIENTRY
1323 _mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
1324                         GLsizei *length, GLchar *infoLog)
1325 {
1326    GET_CURRENT_CONTEXT(ctx);
1327    get_program_info_log(ctx, program, bufSize, length, infoLog);
1328 }
1329
1330
1331 void GLAPIENTRY
1332 _mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
1333                        GLsizei *length, GLchar *infoLog)
1334 {
1335    GET_CURRENT_CONTEXT(ctx);
1336    get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1337 }
1338
1339
1340 void GLAPIENTRY
1341 _mesa_GetShaderSource(GLhandleARB shader, GLsizei maxLength,
1342                          GLsizei *length, GLcharARB *sourceOut)
1343 {
1344    GET_CURRENT_CONTEXT(ctx);
1345    get_shader_source(ctx, shader, maxLength, length, sourceOut);
1346 }
1347
1348
1349 GLhandleARB GLAPIENTRY
1350 _mesa_GetHandleARB(GLenum pname)
1351 {
1352    GET_CURRENT_CONTEXT(ctx);
1353    return get_handle(ctx, pname);
1354 }
1355
1356
1357 GLboolean GLAPIENTRY
1358 _mesa_IsProgram(GLuint name)
1359 {
1360    GET_CURRENT_CONTEXT(ctx);
1361    return is_program(ctx, name);
1362 }
1363
1364
1365 GLboolean GLAPIENTRY
1366 _mesa_IsShader(GLuint name)
1367 {
1368    GET_CURRENT_CONTEXT(ctx);
1369    return is_shader(ctx, name);
1370 }
1371
1372
1373 void GLAPIENTRY
1374 _mesa_LinkProgram(GLhandleARB programObj)
1375 {
1376    GET_CURRENT_CONTEXT(ctx);
1377    link_program(ctx, programObj);
1378 }
1379
1380
1381
1382 /**
1383  * Read shader source code from a file.
1384  * Useful for debugging to override an app's shader.
1385  */
1386 static GLcharARB *
1387 read_shader(const char *fname)
1388 {
1389    const int max = 50*1000;
1390    FILE *f = fopen(fname, "r");
1391    GLcharARB *buffer, *shader;
1392    int len;
1393
1394    if (!f) {
1395       return NULL;
1396    }
1397
1398    buffer = malloc(max);
1399    len = fread(buffer, 1, max, f);
1400    buffer[len] = 0;
1401
1402    fclose(f);
1403
1404    shader = _mesa_strdup(buffer);
1405    free(buffer);
1406
1407    return shader;
1408 }
1409
1410
1411 /**
1412  * Called via glShaderSource() and glShaderSourceARB() API functions.
1413  * Basically, concatenate the source code strings into one long string
1414  * and pass it to _mesa_shader_source().
1415  */
1416 void GLAPIENTRY
1417 _mesa_ShaderSource(GLhandleARB shaderObj, GLsizei count,
1418                       const GLcharARB * const * string, const GLint * length)
1419 {
1420    GET_CURRENT_CONTEXT(ctx);
1421    GLint *offsets;
1422    GLsizei i, totalLength;
1423    GLcharARB *source;
1424    GLuint checksum;
1425
1426    if (!shaderObj || string == NULL) {
1427       _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
1428       return;
1429    }
1430
1431    /*
1432     * This array holds offsets of where the appropriate string ends, thus the
1433     * last element will be set to the total length of the source code.
1434     */
1435    offsets = malloc(count * sizeof(GLint));
1436    if (offsets == NULL) {
1437       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1438       return;
1439    }
1440
1441    for (i = 0; i < count; i++) {
1442       if (string[i] == NULL) {
1443          free((GLvoid *) offsets);
1444          _mesa_error(ctx, GL_INVALID_OPERATION,
1445                      "glShaderSourceARB(null string)");
1446          return;
1447       }
1448       if (length == NULL || length[i] < 0)
1449          offsets[i] = strlen(string[i]);
1450       else
1451          offsets[i] = length[i];
1452       /* accumulate string lengths */
1453       if (i > 0)
1454          offsets[i] += offsets[i - 1];
1455    }
1456
1457    /* Total length of source string is sum off all strings plus two.
1458     * One extra byte for terminating zero, another extra byte to silence
1459     * valgrind warnings in the parser/grammer code.
1460     */
1461    totalLength = offsets[count - 1] + 2;
1462    source = malloc(totalLength * sizeof(GLcharARB));
1463    if (source == NULL) {
1464       free((GLvoid *) offsets);
1465       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
1466       return;
1467    }
1468
1469    for (i = 0; i < count; i++) {
1470       GLint start = (i > 0) ? offsets[i - 1] : 0;
1471       memcpy(source + start, string[i],
1472              (offsets[i] - start) * sizeof(GLcharARB));
1473    }
1474    source[totalLength - 1] = '\0';
1475    source[totalLength - 2] = '\0';
1476
1477    if (SHADER_SUBST) {
1478       /* Compute the shader's source code checksum then try to open a file
1479        * named newshader_<CHECKSUM>.  If it exists, use it in place of the
1480        * original shader source code.  For debugging.
1481        */
1482       char filename[100];
1483       GLcharARB *newSource;
1484
1485       checksum = _mesa_str_checksum(source);
1486
1487       _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);
1488
1489       newSource = read_shader(filename);
1490       if (newSource) {
1491          fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
1492                        shaderObj, checksum, filename);
1493          free(source);
1494          source = newSource;
1495       }
1496    }
1497
1498    shader_source(ctx, shaderObj, source);
1499
1500    if (SHADER_SUBST) {
1501       struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
1502       if (sh)
1503          sh->SourceChecksum = checksum; /* save original checksum */
1504    }
1505
1506    free(offsets);
1507 }
1508
1509
1510 void GLAPIENTRY
1511 _mesa_UseProgram(GLhandleARB program)
1512 {
1513    GET_CURRENT_CONTEXT(ctx);
1514    struct gl_shader_program *shProg;
1515
1516    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1517       _mesa_error(ctx, GL_INVALID_OPERATION,
1518                   "glUseProgram(transform feedback active)");
1519       return;
1520    }
1521
1522    if (program) {
1523       shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
1524       if (!shProg) {
1525          return;
1526       }
1527       if (!shProg->LinkStatus) {
1528          _mesa_error(ctx, GL_INVALID_OPERATION,
1529                      "glUseProgram(program %u not linked)", program);
1530          return;
1531       }
1532
1533       /* debug code */
1534       if (ctx->Shader.Flags & GLSL_USE_PROG) {
1535          print_shader_info(shProg);
1536       }
1537    }
1538    else {
1539       shProg = NULL;
1540    }
1541
1542    _mesa_use_program(ctx, shProg);
1543 }
1544
1545
1546 void GLAPIENTRY
1547 _mesa_ValidateProgram(GLhandleARB program)
1548 {
1549    GET_CURRENT_CONTEXT(ctx);
1550    validate_program(ctx, program);
1551 }
1552
1553
1554 /**
1555  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1556  */
1557 void GLAPIENTRY
1558 _mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1559                                GLint* range, GLint* precision)
1560 {
1561    const struct gl_program_constants *limits;
1562    const struct gl_precision *p;
1563    GET_CURRENT_CONTEXT(ctx);
1564
1565    switch (shadertype) {
1566    case GL_VERTEX_SHADER:
1567       limits = &ctx->Const.Program[MESA_SHADER_VERTEX];
1568       break;
1569    case GL_FRAGMENT_SHADER:
1570       limits = &ctx->Const.Program[MESA_SHADER_FRAGMENT];
1571       break;
1572    default:
1573       _mesa_error(ctx, GL_INVALID_ENUM,
1574                   "glGetShaderPrecisionFormat(shadertype)");
1575       return;
1576    }
1577
1578    switch (precisiontype) {
1579    case GL_LOW_FLOAT:
1580       p = &limits->LowFloat;
1581       break;
1582    case GL_MEDIUM_FLOAT:
1583       p = &limits->MediumFloat;
1584       break;
1585    case GL_HIGH_FLOAT:
1586       p = &limits->HighFloat;
1587       break;
1588    case GL_LOW_INT:
1589       p = &limits->LowInt;
1590       break;
1591    case GL_MEDIUM_INT:
1592       p = &limits->MediumInt;
1593       break;
1594    case GL_HIGH_INT:
1595       p = &limits->HighInt;
1596       break;
1597    default:
1598       _mesa_error(ctx, GL_INVALID_ENUM,
1599                   "glGetShaderPrecisionFormat(precisiontype)");
1600       return;
1601    }
1602
1603    range[0] = p->RangeMin;
1604    range[1] = p->RangeMax;
1605    precision[0] = p->Precision;
1606 }
1607
1608
1609 /**
1610  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1611  */
1612 void GLAPIENTRY
1613 _mesa_ReleaseShaderCompiler(void)
1614 {
1615    _mesa_destroy_shader_compiler_caches();
1616 }
1617
1618
1619 /**
1620  * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1621  */
1622 void GLAPIENTRY
1623 _mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
1624                    const void* binary, GLint length)
1625 {
1626    GET_CURRENT_CONTEXT(ctx);
1627    (void) n;
1628    (void) shaders;
1629    (void) binaryformat;
1630    (void) binary;
1631    (void) length;
1632    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1633 }
1634
1635
1636 void GLAPIENTRY
1637 _mesa_GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
1638                        GLenum *binaryFormat, GLvoid *binary)
1639 {
1640    struct gl_shader_program *shProg;
1641    GET_CURRENT_CONTEXT(ctx);
1642
1643    shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetProgramBinary");
1644    if (!shProg)
1645       return;
1646
1647    if (!shProg->LinkStatus) {
1648       _mesa_error(ctx, GL_INVALID_OPERATION,
1649                   "glGetProgramBinary(program %u not linked)",
1650                   shProg->Name);
1651       return;
1652    }
1653
1654    if (bufSize < 0){
1655       _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramBinary(bufSize < 0)");
1656       return;
1657    }
1658
1659    /* The ARB_get_program_binary spec says:
1660     *
1661     *     "If <length> is NULL, then no length is returned."
1662     */
1663    if (length != NULL)
1664       *length = 0;
1665
1666    (void) binaryFormat;
1667    (void) binary;
1668 }
1669
1670 void GLAPIENTRY
1671 _mesa_ProgramBinary(GLuint program, GLenum binaryFormat,
1672                     const GLvoid *binary, GLsizei length)
1673 {
1674    struct gl_shader_program *shProg;
1675    GET_CURRENT_CONTEXT(ctx);
1676
1677    shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramBinary");
1678    if (!shProg)
1679       return;
1680
1681    (void) binaryFormat;
1682    (void) binary;
1683    (void) length;
1684    _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
1685 }
1686
1687
1688 void GLAPIENTRY
1689 _mesa_ProgramParameteri(GLuint program, GLenum pname, GLint value)
1690 {
1691    struct gl_shader_program *shProg;
1692    GET_CURRENT_CONTEXT(ctx);
1693
1694    shProg = _mesa_lookup_shader_program_err(ctx, program,
1695                                             "glProgramParameteri");
1696    if (!shProg)
1697       return;
1698
1699    switch (pname) {
1700    case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
1701       /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
1702        * is part of OpenGL ES 3.0.  For the ES2 case, this function shouldn't
1703        * even be in the dispatch table, so we shouldn't need to expclicitly
1704        * check here.
1705        *
1706        * On desktop, we ignore the 3.0+ requirement because it is silly.
1707        */
1708
1709       /* The ARB_get_program_binary extension spec says:
1710        *
1711        *     "An INVALID_VALUE error is generated if the <value> argument to
1712        *     ProgramParameteri is not TRUE or FALSE."
1713        */
1714       if (value != GL_TRUE && value != GL_FALSE) {
1715          _mesa_error(ctx, GL_INVALID_VALUE,
1716                      "glProgramParameteri(pname=%s, value=%d): "
1717                      "value must be 0 or 1.",
1718                      _mesa_lookup_enum_by_nr(pname),
1719                      value);
1720          return;
1721       }
1722
1723       /* No need to notify the driver.  Any changes will actually take effect
1724        * the next time the shader is linked.
1725        *
1726        * The ARB_get_program_binary extension spec says:
1727        *
1728        *     "To indicate that a program binary is likely to be retrieved,
1729        *     ProgramParameteri should be called with <pname>
1730        *     PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
1731        *     will not be in effect until the next time LinkProgram or
1732        *     ProgramBinary has been called successfully."
1733        *
1734        * The resloution of issue 9 in the extension spec also says:
1735        *
1736        *     "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
1737        *     to indicate to the GL implementation that this program will
1738        *     likely be saved with GetProgramBinary at some point. This will
1739        *     give the GL implementation the opportunity to track any state
1740        *     changes made to the program before being saved such that when it
1741        *     is loaded again a recompile can be avoided."
1742        */
1743       shProg->BinaryRetreivableHint = value;
1744       return;
1745
1746    case GL_PROGRAM_SEPARABLE:
1747       if (!ctx->Extensions.ARB_separate_shader_objects)
1748          break;
1749
1750       /* Spec imply that the behavior is the same as ARB_get_program_binary
1751        * Chapter 7.3 Program Objects
1752        */
1753       if (value != GL_TRUE && value != GL_FALSE) {
1754          _mesa_error(ctx, GL_INVALID_VALUE,
1755                      "glProgramParameteri(pname=%s, value=%d): "
1756                      "value must be 0 or 1.",
1757                      _mesa_lookup_enum_by_nr(pname),
1758                      value);
1759          return;
1760       }
1761       shProg->SeparateShader = value;
1762       return;
1763
1764    default:
1765       break;
1766    }
1767
1768    _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteri(pname=%s)",
1769                _mesa_lookup_enum_by_nr(pname));
1770 }
1771
1772 void
1773 _mesa_use_shader_program(struct gl_context *ctx, GLenum type,
1774                          struct gl_shader_program *shProg)
1775 {
1776    use_shader_program(ctx, type, shProg);
1777
1778    if (ctx->Driver.UseProgram)
1779       ctx->Driver.UseProgram(ctx, shProg);
1780 }
1781
1782
1783 /**
1784  * For GL_EXT_separate_shader_objects
1785  */
1786 void GLAPIENTRY
1787 _mesa_UseShaderProgramEXT(GLenum type, GLuint program)
1788 {
1789    GET_CURRENT_CONTEXT(ctx);
1790    struct gl_shader_program *shProg = NULL;
1791
1792    if (!_mesa_validate_shader_target(ctx, type)) {
1793       _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");
1794       return;
1795    }
1796
1797    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
1798       _mesa_error(ctx, GL_INVALID_OPERATION,
1799                   "glUseShaderProgramEXT(transform feedback is active)");
1800       return;
1801    }
1802
1803    if (program) {
1804       shProg = _mesa_lookup_shader_program_err(ctx, program,
1805                                                "glUseShaderProgramEXT");
1806       if (shProg == NULL)
1807          return;
1808
1809       if (!shProg->LinkStatus) {
1810          _mesa_error(ctx, GL_INVALID_OPERATION,
1811                      "glUseShaderProgramEXT(program not linked)");
1812          return;
1813       }
1814    }
1815
1816    _mesa_use_shader_program(ctx, type, shProg);
1817 }
1818
1819
1820 /**
1821  * For GL_EXT_separate_shader_objects
1822  */
1823 void GLAPIENTRY
1824 _mesa_ActiveProgramEXT(GLuint program)
1825 {
1826    GET_CURRENT_CONTEXT(ctx);
1827    struct gl_shader_program *shProg = (program != 0)
1828       ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")
1829       : NULL;
1830
1831    _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
1832    return;
1833 }
1834
1835 static GLuint
1836 _mesa_create_shader_program(struct gl_context* ctx, GLboolean separate,
1837                             GLenum type, GLsizei count, const GLchar* const *strings)
1838 {
1839    const GLuint shader = create_shader(ctx, type);
1840    GLuint program = 0;
1841
1842    if (shader) {
1843       _mesa_ShaderSource(shader, count, strings, NULL);
1844
1845       compile_shader(ctx, shader);
1846
1847       program = create_shader_program(ctx);
1848       if (program) {
1849          struct gl_shader_program *shProg;
1850          struct gl_shader *sh;
1851          GLint compiled = GL_FALSE;
1852
1853          shProg = _mesa_lookup_shader_program(ctx, program);
1854          sh = _mesa_lookup_shader(ctx, shader);
1855
1856          shProg->SeparateShader = separate;
1857
1858          get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
1859          if (compiled) {
1860             attach_shader(ctx, program, shader);
1861             link_program(ctx, program);
1862             detach_shader(ctx, program, shader);
1863
1864 #if 0
1865             /* Possibly... */
1866             if (active-user-defined-varyings-in-linked-program) {
1867                append-error-to-info-log;
1868                shProg->LinkStatus = GL_FALSE;
1869             }
1870 #endif
1871          }
1872
1873          ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
1874       }
1875
1876       delete_shader(ctx, shader);
1877    }
1878
1879    return program;
1880 }
1881
1882
1883 /**
1884  * Copy program-specific data generated by linking from the gl_shader_program
1885  * object to a specific gl_program object.
1886  */
1887 void
1888 _mesa_copy_linked_program_data(gl_shader_stage type,
1889                                const struct gl_shader_program *src,
1890                                struct gl_program *dst)
1891 {
1892    switch (type) {
1893    case MESA_SHADER_VERTEX:
1894       dst->UsesClipDistanceOut = src->Vert.UsesClipDistance;
1895       break;
1896    case MESA_SHADER_GEOMETRY: {
1897       struct gl_geometry_program *dst_gp = (struct gl_geometry_program *) dst;
1898       dst_gp->VerticesIn = src->Geom.VerticesIn;
1899       dst_gp->VerticesOut = src->Geom.VerticesOut;
1900       dst_gp->Invocations = src->Geom.Invocations;
1901       dst_gp->InputType = src->Geom.InputType;
1902       dst_gp->OutputType = src->Geom.OutputType;
1903       dst->UsesClipDistanceOut = src->Geom.UsesClipDistance;
1904       dst_gp->UsesEndPrimitive = src->Geom.UsesEndPrimitive;
1905    }
1906       break;
1907    case MESA_SHADER_COMPUTE: {
1908       struct gl_compute_program *dst_cp = (struct gl_compute_program *) dst;
1909       int i;
1910       for (i = 0; i < 3; i++)
1911          dst_cp->LocalSize[i] = src->Comp.LocalSize[i];
1912    }
1913       break;
1914    default:
1915       break;
1916    }
1917 }
1918
1919
1920 /**
1921  * For GL_EXT_separate_shader_objects
1922  */
1923 GLuint GLAPIENTRY
1924 _mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)
1925 {
1926    GET_CURRENT_CONTEXT(ctx);
1927
1928    return _mesa_create_shader_program(ctx, GL_FALSE, type, 1, &string);
1929 }
1930
1931 /**
1932  * ARB_separate_shader_objects: Compile & Link Program
1933  */
1934 GLuint GLAPIENTRY
1935 _mesa_CreateShaderProgramv(GLenum type, GLsizei count,
1936                            const GLchar* const *strings)
1937 {
1938    return 0;
1939 }