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