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