src/mesa/main/api_validate.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include <stdbool.h>
  26 #include "glheader.h"
  27 #include "api_validate.h"
  28 #include "bufferobj.h"
  29 #include "context.h"
  30 #include "imports.h"
  31 #include "mtypes.h"
  32 #include "enums.h"
  33 #include "vbo/vbo.h"
  34 #include "transformfeedback.h"
  35 #include <stdbool.h>
  36
  37
  38 /**
  39  * Check if OK to draw arrays/elements.
  40  */
  41 static bool
  42 check_valid_to_render(struct gl_context *ctx, const char *function)
  43 {
  44    if (!_mesa_valid_to_render(ctx, function)) {
  45       return false;
  46    }
  47
  48    switch (ctx->API) {
  49    case API_OPENGLES2:
  50       /* For ES2, we can draw if we have a vertex program/shader). */
  51       return ctx->VertexProgram._Current != NULL;
  52
  53    case API_OPENGLES:
  54       /* For OpenGL ES, only draw if we have vertex positions
  55        */
  56       if (!ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POS].Enabled)
  57          return false;
  58       break;
  59
  60    case API_OPENGL_CORE:
  61       /* Section 10.4 (Drawing Commands Using Vertex Arrays) of the OpenGL 4.5
  62        * Core Profile spec says:
  63        *
  64        *     "An INVALID_OPERATION error is generated if no vertex array
  65        *     object is bound (see section 10.3.1)."
  66        */
  67       if (ctx->Array.VAO == ctx->Array.DefaultVAO) {
  68          _mesa_error(ctx, GL_INVALID_OPERATION, "%s(no VAO bound)", function);
  69          return false;
  70       }
  71
  72       /* The spec argues that this is allowed because a tess ctrl shader
  73        * without a tess eval shader can be used with transform feedback.
  74        * However, glBeginTransformFeedback doesn't allow GL_PATCHES and
  75        * therefore doesn't allow tessellation.
  76        *
  77        * Further investigation showed that this is indeed a spec bug and
  78        * a tess ctrl shader without a tess eval shader shouldn't have been
  79        * allowed, because there is no API in GL 4.0 that can make use this
  80        * to produce something useful.
  81        *
  82        * Also, all vendors except one don't support a tess ctrl shader without
  83        * a tess eval shader anyway.
  84        */
  85       if (ctx->TessCtrlProgram._Current && !ctx->TessEvalProgram._Current) {
  86          _mesa_error(ctx, GL_INVALID_OPERATION,
  87                      "%s(tess eval shader is missing)", function);
  88          return false;
  89       }
  90
  91       /* Section 7.3 (Program Objects) of the OpenGL 4.5 Core Profile spec
  92        * says:
  93        *
  94        *     "If there is no active program for the vertex or fragment shader
  95        *     stages, the results of vertex and/or fragment processing will be
  96        *     undefined. However, this is not an error."
  97        *
  98        * The fragment shader is not tested here because other state (e.g.,
  99        * GL_RASTERIZER_DISCARD) affects whether or not we actually care.
 100        */
 101       return ctx->VertexProgram._Current != NULL;
 102
 103    case API_OPENGL_COMPAT:
 104       if (ctx->VertexProgram._Current != NULL) {
 105          /* Draw regardless of whether or not we have any vertex arrays.
 106           * (Ex: could draw a point using a constant vertex pos)
 107           */
 108          return true;
 109       } else {
 110          /* Draw if we have vertex positions (GL_VERTEX_ARRAY or generic
 111           * array [0]).
 112           */
 113          return (ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POS].Enabled ||
 114                  ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_GENERIC0].Enabled);
 115       }
 116       break;
 117
 118    default:
 119       unreachable("Invalid API value in check_valid_to_render()");
 120    }
 121
 122    return true;
 123 }
 124
 125
 126 /**
 127  * Is 'mode' a valid value for glBegin(), glDrawArrays(), glDrawElements(),
 128  * etc?  The set of legal values depends on whether geometry shaders/programs
 129  * are supported.
 130  * Note: This may be called during display list compilation.
 131  */
 132 bool
 133 _mesa_is_valid_prim_mode(struct gl_context *ctx, GLenum mode)
 134 {
 135    /* The overwhelmingly common case is (mode <= GL_TRIANGLE_FAN).  Test that
 136     * first and exit.  You would think that a switch-statement would be the
 137     * right approach, but at least GCC 4.7.2 generates some pretty dire code
 138     * for the common case.
 139     */
 140    if (likely(mode <= GL_TRIANGLE_FAN))
 141       return true;
 142
 143    if (mode <= GL_POLYGON)
 144       return (ctx->API == API_OPENGL_COMPAT);
 145
 146    if (mode <= GL_TRIANGLE_STRIP_ADJACENCY)
 147       return _mesa_has_geometry_shaders(ctx);
 148
 149    if (mode == GL_PATCHES)
 150       return _mesa_has_tessellation(ctx);
 151
 152    return false;
 153 }
 154
 155
 156 /**
 157  * Is 'mode' a valid value for glBegin(), glDrawArrays(), glDrawElements(),
 158  * etc?  Also, do additional checking related to transformation feedback.
 159  * Note: this function cannot be called during glNewList(GL_COMPILE) because
 160  * this code depends on current transform feedback state.
 161  * Also, do additional checking related to tessellation shaders.
 162  */
 163 GLboolean
 164 _mesa_valid_prim_mode(struct gl_context *ctx, GLenum mode, const char *name)
 165 {
 166    bool valid_enum = _mesa_is_valid_prim_mode(ctx, mode);
 167
 168    if (!valid_enum) {
 169       _mesa_error(ctx, GL_INVALID_ENUM, "%s(mode=%x)", name, mode);
 170       return GL_FALSE;
 171    }
 172
 173    /* From the ARB_geometry_shader4 spec:
 174     *
 175     * The error INVALID_OPERATION is generated if Begin, or any command that
 176     * implicitly calls Begin, is called when a geometry shader is active and:
 177     *
 178     * * the input primitive type of the current geometry shader is
 179     *   POINTS and <mode> is not POINTS,
 180     *
 181     * * the input primitive type of the current geometry shader is
 182     *   LINES and <mode> is not LINES, LINE_STRIP, or LINE_LOOP,
 183     *
 184     * * the input primitive type of the current geometry shader is
 185     *   TRIANGLES and <mode> is not TRIANGLES, TRIANGLE_STRIP or
 186     *   TRIANGLE_FAN,
 187     *
 188     * * the input primitive type of the current geometry shader is
 189     *   LINES_ADJACENCY_ARB and <mode> is not LINES_ADJACENCY_ARB or
 190     *   LINE_STRIP_ADJACENCY_ARB, or
 191     *
 192     * * the input primitive type of the current geometry shader is
 193     *   TRIANGLES_ADJACENCY_ARB and <mode> is not
 194     *   TRIANGLES_ADJACENCY_ARB or TRIANGLE_STRIP_ADJACENCY_ARB.
 195     *
 196     * The GL spec doesn't mention any interaction with tessellation, which
 197     * is clearly a spec bug. The same rule should apply, but instead of
 198     * the draw primitive mode, the tessellation evaluation shader primitive
 199     * mode should be used for the checking.
 200    */
 201    if (ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]) {
 202       const GLenum geom_mode =
 203          ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]->Geom.InputType;
 204       struct gl_shader_program *tes =
 205          ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_EVAL];
 206       GLenum mode_before_gs = mode;
 207
 208       if (tes) {
 209          if (tes->TessEval.PointMode)
 210             mode_before_gs = GL_POINTS;
 211          else if (tes->TessEval.PrimitiveMode == GL_ISOLINES)
 212             mode_before_gs = GL_LINES;
 213          else
 214             /* the GL_QUADS mode generates triangles too */
 215             mode_before_gs = GL_TRIANGLES;
 216       }
 217
 218       switch (mode_before_gs) {
 219       case GL_POINTS:
 220          valid_enum = (geom_mode == GL_POINTS);
 221          break;
 222       case GL_LINES:
 223       case GL_LINE_LOOP:
 224       case GL_LINE_STRIP:
 225          valid_enum = (geom_mode == GL_LINES);
 226          break;
 227       case GL_TRIANGLES:
 228       case GL_TRIANGLE_STRIP:
 229       case GL_TRIANGLE_FAN:
 230          valid_enum = (geom_mode == GL_TRIANGLES);
 231          break;
 232       case GL_QUADS:
 233       case GL_QUAD_STRIP:
 234       case GL_POLYGON:
 235          valid_enum = false;
 236          break;
 237       case GL_LINES_ADJACENCY:
 238       case GL_LINE_STRIP_ADJACENCY:
 239          valid_enum = (geom_mode == GL_LINES_ADJACENCY);
 240          break;
 241       case GL_TRIANGLES_ADJACENCY:
 242       case GL_TRIANGLE_STRIP_ADJACENCY:
 243          valid_enum = (geom_mode == GL_TRIANGLES_ADJACENCY);
 244          break;
 245       default:
 246          valid_enum = false;
 247          break;
 248       }
 249       if (!valid_enum) {
 250          _mesa_error(ctx, GL_INVALID_OPERATION,
 251                      "%s(mode=%s vs geometry shader input %s)",
 252                      name,
 253                      _mesa_lookup_prim_by_nr(mode_before_gs),
 254                      _mesa_lookup_prim_by_nr(geom_mode));
 255          return GL_FALSE;
 256       }
 257    }
 258
 259    /* From the OpenGL 4.0 (Core Profile) spec (section 2.12):
 260     *
 261     *     "Tessellation operates only on patch primitives. If tessellation is
 262     *      active, any command that transfers vertices to the GL will
 263     *      generate an INVALID_OPERATION error if the primitive mode is not
 264     *      PATCHES.
 265     *      Patch primitives are not supported by pipeline stages below the
 266     *      tessellation evaluation shader. If there is no active program
 267     *      object or the active program object does not contain a tessellation
 268     *      evaluation shader, the error INVALID_OPERATION is generated by any
 269     *      command that transfers vertices to the GL if the primitive mode is
 270     *      PATCHES."
 271     *
 272     */
 273    if (ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_EVAL] ||
 274        ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_CTRL]) {
 275       if (mode != GL_PATCHES) {
 276          _mesa_error(ctx, GL_INVALID_OPERATION,
 277                      "only GL_PATCHES valid with tessellation");
 278          return GL_FALSE;
 279       }
 280    }
 281    else {
 282       if (mode == GL_PATCHES) {
 283          _mesa_error(ctx, GL_INVALID_OPERATION,
 284                      "GL_PATCHES only valid with tessellation");
 285          return GL_FALSE;
 286       }
 287    }
 288
 289    /* From the GL_EXT_transform_feedback spec:
 290     *
 291     *     "The error INVALID_OPERATION is generated if Begin, or any command
 292     *      that performs an explicit Begin, is called when:
 293     *
 294     *      * a geometry shader is not active and <mode> does not match the
 295     *        allowed begin modes for the current transform feedback state as
 296     *        given by table X.1.
 297     *
 298     *      * a geometry shader is active and the output primitive type of the
 299     *        geometry shader does not match the allowed begin modes for the
 300     *        current transform feedback state as given by table X.1.
 301     *
 302     */
 303    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
 304       GLboolean pass = GL_TRUE;
 305
 306       if(ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]) {
 307          switch (ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]->Geom.OutputType) {
 308          case GL_POINTS:
 309             pass = ctx->TransformFeedback.Mode == GL_POINTS;
 310             break;
 311          case GL_LINE_STRIP:
 312             pass = ctx->TransformFeedback.Mode == GL_LINES;
 313             break;
 314          case GL_TRIANGLE_STRIP:
 315             pass = ctx->TransformFeedback.Mode == GL_TRIANGLES;
 316             break;
 317          default:
 318             pass = GL_FALSE;
 319          }
 320       }
 321       else if (ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_EVAL]) {
 322          struct gl_shader_program *tes =
 323             ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_EVAL];
 324
 325          if (tes->TessEval.PointMode)
 326             pass = ctx->TransformFeedback.Mode == GL_POINTS;
 327          else if (tes->TessEval.PrimitiveMode == GL_ISOLINES)
 328             pass = ctx->TransformFeedback.Mode == GL_LINES;
 329          else
 330             pass = ctx->TransformFeedback.Mode == GL_TRIANGLES;
 331       }
 332       else {
 333          switch (mode) {
 334          case GL_POINTS:
 335             pass = ctx->TransformFeedback.Mode == GL_POINTS;
 336             break;
 337          case GL_LINES:
 338          case GL_LINE_STRIP:
 339          case GL_LINE_LOOP:
 340             pass = ctx->TransformFeedback.Mode == GL_LINES;
 341             break;
 342          default:
 343             pass = ctx->TransformFeedback.Mode == GL_TRIANGLES;
 344             break;
 345          }
 346       }
 347       if (!pass) {
 348          _mesa_error(ctx, GL_INVALID_OPERATION,
 349                          "%s(mode=%s vs transform feedback %s)",
 350                          name,
 351                          _mesa_lookup_prim_by_nr(mode),
 352                          _mesa_lookup_prim_by_nr(ctx->TransformFeedback.Mode));
 353          return GL_FALSE;
 354       }
 355    }
 356
 357    return GL_TRUE;
 358 }
 359
 360 /**
 361  * Verify that the element type is valid.
 362  *
 363  * Generates \c GL_INVALID_ENUM and returns \c false if it is not.
 364  */
 365 static bool
 366 valid_elements_type(struct gl_context *ctx, GLenum type, const char *name)
 367 {
 368    switch (type) {
 369    case GL_UNSIGNED_BYTE:
 370    case GL_UNSIGNED_SHORT:
 371    case GL_UNSIGNED_INT:
 372       return true;
 373
 374    default:
 375       _mesa_error(ctx, GL_INVALID_ENUM, "%s(type = %s)", name,
 376                   _mesa_enum_to_string(type));
 377       return false;
 378    }
 379 }
 380
 381 static bool
 382 validate_DrawElements_common(struct gl_context *ctx,
 383                              GLenum mode, GLsizei count, GLenum type,
 384                              const GLvoid *indices,
 385                              const char *caller)
 386 {
 387    /* From the GLES3 specification, section 2.14.2 (Transform Feedback
 388     * Primitive Capture):
 389     *
 390     *   The error INVALID_OPERATION is also generated by DrawElements,
 391     *   DrawElementsInstanced, and DrawRangeElements while transform feedback
 392     *   is active and not paused, regardless of mode.
 393     */
 394    if (_mesa_is_gles3(ctx) && _mesa_is_xfb_active_and_unpaused(ctx)) {
 395       _mesa_error(ctx, GL_INVALID_OPERATION,
 396                   "%s(transform feedback active)", caller);
 397       return false;
 398    }
 399
 400    if (count < 0) {
 401       _mesa_error(ctx, GL_INVALID_VALUE, "%s(count)", caller);
 402       return false;
 403    }
 404
 405    if (!_mesa_valid_prim_mode(ctx, mode, caller)) {
 406       return false;
 407    }
 408
 409    if (!valid_elements_type(ctx, type, caller))
 410       return false;
 411
 412    if (!check_valid_to_render(ctx, caller))
 413       return false;
 414
 415    /* Not using a VBO for indices, so avoid NULL pointer derefs later.
 416     */
 417    if (!_mesa_is_bufferobj(ctx->Array.VAO->IndexBufferObj) && indices == NULL)
 418       return false;
 419
 420    if (count == 0)
 421       return false;
 422
 423    return true;
 424 }
 425
 426 /**
 427  * Error checking for glDrawElements().  Includes parameter checking
 428  * and VBO bounds checking.
 429  * \return GL_TRUE if OK to render, GL_FALSE if error found
 430  */
 431 GLboolean
 432 _mesa_validate_DrawElements(struct gl_context *ctx,
 433                             GLenum mode, GLsizei count, GLenum type,
 434                             const GLvoid *indices)
 435 {
 436    FLUSH_CURRENT(ctx, 0);
 437
 438    return validate_DrawElements_common(ctx, mode, count, type, indices,
 439                                        "glDrawElements");
 440 }
 441
 442
 443 /**
 444  * Error checking for glMultiDrawElements().  Includes parameter checking
 445  * and VBO bounds checking.
 446  * \return GL_TRUE if OK to render, GL_FALSE if error found
 447  */
 448 GLboolean
 449 _mesa_validate_MultiDrawElements(struct gl_context *ctx,
 450                                  GLenum mode, const GLsizei *count,
 451                                  GLenum type, const GLvoid * const *indices,
 452                                  GLuint primcount)
 453 {
 454    unsigned i;
 455
 456    FLUSH_CURRENT(ctx, 0);
 457
 458    for (i = 0; i < primcount; i++) {
 459       if (count[i] < 0) {
 460          _mesa_error(ctx, GL_INVALID_VALUE,
 461                      "glMultiDrawElements(count)" );
 462          return GL_FALSE;
 463       }
 464    }
 465
 466    if (!_mesa_valid_prim_mode(ctx, mode, "glMultiDrawElements")) {
 467       return GL_FALSE;
 468    }
 469
 470    if (!valid_elements_type(ctx, type, "glMultiDrawElements"))
 471       return GL_FALSE;
 472
 473    if (!check_valid_to_render(ctx, "glMultiDrawElements"))
 474       return GL_FALSE;
 475
 476    /* Not using a VBO for indices, so avoid NULL pointer derefs later.
 477     */
 478    if (!_mesa_is_bufferobj(ctx->Array.VAO->IndexBufferObj)) {
 479       for (i = 0; i < primcount; i++) {
 480          if (!indices[i])
 481             return GL_FALSE;
 482       }
 483    }
 484
 485    return GL_TRUE;
 486 }
 487
 488
 489 /**
 490  * Error checking for glDrawRangeElements().  Includes parameter checking
 491  * and VBO bounds checking.
 492  * \return GL_TRUE if OK to render, GL_FALSE if error found
 493  */
 494 GLboolean
 495 _mesa_validate_DrawRangeElements(struct gl_context *ctx, GLenum mode,
 496                                  GLuint start, GLuint end,
 497                                  GLsizei count, GLenum type,
 498                                  const GLvoid *indices)
 499 {
 500    FLUSH_CURRENT(ctx, 0);
 501
 502    if (end < start) {
 503       _mesa_error(ctx, GL_INVALID_VALUE, "glDrawRangeElements(end<start)");
 504       return GL_FALSE;
 505    }
 506
 507    return validate_DrawElements_common(ctx, mode, count, type, indices,
 508                                        "glDrawRangeElements");
 509 }
 510
 511
 512 /**
 513  * Called from the tnl module to error check the function parameters and
 514  * verify that we really can draw something.
 515  * \return GL_TRUE if OK to render, GL_FALSE if error found
 516  */
 517 GLboolean
 518 _mesa_validate_DrawArrays(struct gl_context *ctx, GLenum mode, GLsizei count)
 519 {
 520    struct gl_transform_feedback_object *xfb_obj
 521       = ctx->TransformFeedback.CurrentObject;
 522    FLUSH_CURRENT(ctx, 0);
 523
 524    if (count < 0) {
 525       _mesa_error(ctx, GL_INVALID_VALUE, "glDrawArrays(count)" );
 526       return GL_FALSE;
 527    }
 528
 529    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawArrays")) {
 530       return GL_FALSE;
 531    }
 532
 533    if (!check_valid_to_render(ctx, "glDrawArrays"))
 534       return GL_FALSE;
 535
 536    /* From the GLES3 specification, section 2.14.2 (Transform Feedback
 537     * Primitive Capture):
 538     *
 539     *   The error INVALID_OPERATION is generated by DrawArrays and
 540     *   DrawArraysInstanced if recording the vertices of a primitive to the
 541     *   buffer objects being used for transform feedback purposes would result
 542     *   in either exceeding the limits of any buffer object’s size, or in
 543     *   exceeding the end position offset + size − 1, as set by
 544     *   BindBufferRange.
 545     *
 546     * This is in contrast to the behaviour of desktop GL, where the extra
 547     * primitives are silently dropped from the transform feedback buffer.
 548     */
 549    if (_mesa_is_gles3(ctx) && _mesa_is_xfb_active_and_unpaused(ctx)) {
 550       size_t prim_count = vbo_count_tessellated_primitives(mode, count, 1);
 551       if (xfb_obj->GlesRemainingPrims < prim_count) {
 552          _mesa_error(ctx, GL_INVALID_OPERATION,
 553                      "glDrawArrays(exceeds transform feedback size)");
 554          return GL_FALSE;
 555       }
 556       xfb_obj->GlesRemainingPrims -= prim_count;
 557    }
 558
 559    if (count == 0)
 560       return GL_FALSE;
 561
 562    return GL_TRUE;
 563 }
 564
 565
 566 GLboolean
 567 _mesa_validate_DrawArraysInstanced(struct gl_context *ctx, GLenum mode, GLint first,
 568                                    GLsizei count, GLsizei numInstances)
 569 {
 570    struct gl_transform_feedback_object *xfb_obj
 571       = ctx->TransformFeedback.CurrentObject;
 572    FLUSH_CURRENT(ctx, 0);
 573
 574    if (count < 0) {
 575       _mesa_error(ctx, GL_INVALID_VALUE,
 576                   "glDrawArraysInstanced(count=%d)", count);
 577       return GL_FALSE;
 578    }
 579
 580    if (first < 0) {
 581       _mesa_error(ctx, GL_INVALID_VALUE,
 582                   "glDrawArraysInstanced(start=%d)", first);
 583       return GL_FALSE;
 584    }
 585
 586    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawArraysInstanced")) {
 587       return GL_FALSE;
 588    }
 589
 590    if (numInstances <= 0) {
 591       if (numInstances < 0)
 592          _mesa_error(ctx, GL_INVALID_VALUE,
 593                      "glDrawArraysInstanced(numInstances=%d)", numInstances);
 594       return GL_FALSE;
 595    }
 596
 597    if (!check_valid_to_render(ctx, "glDrawArraysInstanced(invalid to render)"))
 598       return GL_FALSE;
 599
 600    /* From the GLES3 specification, section 2.14.2 (Transform Feedback
 601     * Primitive Capture):
 602     *
 603     *   The error INVALID_OPERATION is generated by DrawArrays and
 604     *   DrawArraysInstanced if recording the vertices of a primitive to the
 605     *   buffer objects being used for transform feedback purposes would result
 606     *   in either exceeding the limits of any buffer object’s size, or in
 607     *   exceeding the end position offset + size − 1, as set by
 608     *   BindBufferRange.
 609     *
 610     * This is in contrast to the behaviour of desktop GL, where the extra
 611     * primitives are silently dropped from the transform feedback buffer.
 612     */
 613    if (_mesa_is_gles3(ctx) && _mesa_is_xfb_active_and_unpaused(ctx)) {
 614       size_t prim_count
 615          = vbo_count_tessellated_primitives(mode, count, numInstances);
 616       if (xfb_obj->GlesRemainingPrims < prim_count) {
 617          _mesa_error(ctx, GL_INVALID_OPERATION,
 618                      "glDrawArraysInstanced(exceeds transform feedback size)");
 619          return GL_FALSE;
 620       }
 621       xfb_obj->GlesRemainingPrims -= prim_count;
 622    }
 623
 624    if (count == 0)
 625       return GL_FALSE;
 626
 627    return GL_TRUE;
 628 }
 629
 630
 631 GLboolean
 632 _mesa_validate_DrawElementsInstanced(struct gl_context *ctx,
 633                                      GLenum mode, GLsizei count, GLenum type,
 634                                      const GLvoid *indices, GLsizei numInstances)
 635 {
 636    FLUSH_CURRENT(ctx, 0);
 637
 638    if (numInstances < 0) {
 639       _mesa_error(ctx, GL_INVALID_VALUE,
 640                   "glDrawElementsInstanced(numInstances=%d)", numInstances);
 641       return GL_FALSE;
 642    }
 643
 644    return validate_DrawElements_common(ctx, mode, count, type, indices,
 645                                        "glDrawElementsInstanced")
 646       && (numInstances > 0);
 647 }
 648
 649
 650 GLboolean
 651 _mesa_validate_DrawTransformFeedback(struct gl_context *ctx,
 652                                      GLenum mode,
 653                                      struct gl_transform_feedback_object *obj,
 654                                      GLuint stream,
 655                                      GLsizei numInstances)
 656 {
 657    FLUSH_CURRENT(ctx, 0);
 658
 659    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawTransformFeedback*(mode)")) {
 660       return GL_FALSE;
 661    }
 662
 663    if (!obj) {
 664       _mesa_error(ctx, GL_INVALID_VALUE, "glDrawTransformFeedback*(name)");
 665       return GL_FALSE;
 666    }
 667
 668    if (stream >= ctx->Const.MaxVertexStreams) {
 669       _mesa_error(ctx, GL_INVALID_VALUE,
 670                   "glDrawTransformFeedbackStream*(index>=MaxVertexStream)");
 671       return GL_FALSE;
 672    }
 673
 674    if (!obj->EndedAnytime) {
 675       _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawTransformFeedback*");
 676       return GL_FALSE;
 677    }
 678
 679    if (numInstances <= 0) {
 680       if (numInstances < 0)
 681          _mesa_error(ctx, GL_INVALID_VALUE,
 682                      "glDrawTransformFeedback*Instanced(numInstances=%d)",
 683                      numInstances);
 684       return GL_FALSE;
 685    }
 686
 687    if (!check_valid_to_render(ctx, "glDrawTransformFeedback*")) {
 688       return GL_FALSE;
 689    }
 690
 691    return GL_TRUE;
 692 }
 693
 694 static GLboolean
 695 valid_draw_indirect(struct gl_context *ctx,
 696                     GLenum mode, const GLvoid *indirect,
 697                     GLsizei size, const char *name)
 698 {
 699    const GLsizeiptr end = (GLsizeiptr)indirect + size;
 700
 701    /* OpenGL ES 3.1 spec. section 10.5:
 702     *
 703     *      "DrawArraysIndirect requires that all data sourced for the
 704     *      command, including the DrawArraysIndirectCommand
 705     *      structure,  be in buffer objects,  and may not be called when
 706     *      the default vertex array object is bound."
 707     */
 708    if (ctx->Array.VAO == ctx->Array.DefaultVAO) {
 709       _mesa_error(ctx, GL_INVALID_OPERATION, "(no VAO bound)");
 710       return GL_FALSE;
 711    }
 712
 713    if (!_mesa_valid_prim_mode(ctx, mode, name))
 714       return GL_FALSE;
 715
 716    /* OpenGL ES 3.1 specification, section 10.5:
 717     *
 718     *      "An INVALID_OPERATION error is generated if
 719     *      transform feedback is active and not paused."
 720     */
 721    if (_mesa_is_gles31(ctx) && _mesa_is_xfb_active_and_unpaused(ctx)) {
 722       _mesa_error(ctx, GL_INVALID_OPERATION,
 723                   "%s(TransformFeedback is active and not paused)", name);
 724    }
 725
 726    /* From OpenGL version 4.4. section 10.5
 727     * and OpenGL ES 3.1, section 10.6:
 728     *
 729     *      "An INVALID_VALUE error is generated if indirect is not a
 730     *       multiple of the size, in basic machine units, of uint."
 731     */
 732    if ((GLsizeiptr)indirect & (sizeof(GLuint) - 1)) {
 733       _mesa_error(ctx, GL_INVALID_VALUE,
 734                   "%s(indirect is not aligned)", name);
 735       return GL_FALSE;
 736    }
 737
 738    if (!_mesa_is_bufferobj(ctx->DrawIndirectBuffer)) {
 739       _mesa_error(ctx, GL_INVALID_OPERATION,
 740                   "%s: no buffer bound to DRAW_INDIRECT_BUFFER", name);
 741       return GL_FALSE;
 742    }
 743
 744    if (_mesa_check_disallowed_mapping(ctx->DrawIndirectBuffer)) {
 745       _mesa_error(ctx, GL_INVALID_OPERATION,
 746                   "%s(DRAW_INDIRECT_BUFFER is mapped)", name);
 747       return GL_FALSE;
 748    }
 749
 750    /* From the ARB_draw_indirect specification:
 751     * "An INVALID_OPERATION error is generated if the commands source data
 752     *  beyond the end of the buffer object [...]"
 753     */
 754    if (ctx->DrawIndirectBuffer->Size < end) {
 755       _mesa_error(ctx, GL_INVALID_OPERATION,
 756                   "%s(DRAW_INDIRECT_BUFFER too small)", name);
 757       return GL_FALSE;
 758    }
 759
 760    if (!check_valid_to_render(ctx, name))
 761       return GL_FALSE;
 762
 763    return GL_TRUE;
 764 }
 765
 766 static inline GLboolean
 767 valid_draw_indirect_elements(struct gl_context *ctx,
 768                              GLenum mode, GLenum type, const GLvoid *indirect,
 769                              GLsizeiptr size, const char *name)
 770 {
 771    if (!valid_elements_type(ctx, type, name))
 772       return GL_FALSE;
 773
 774    /*
 775     * Unlike regular DrawElementsInstancedBaseVertex commands, the indices
 776     * may not come from a client array and must come from an index buffer.
 777     * If no element array buffer is bound, an INVALID_OPERATION error is
 778     * generated.
 779     */
 780    if (!_mesa_is_bufferobj(ctx->Array.VAO->IndexBufferObj)) {
 781       _mesa_error(ctx, GL_INVALID_OPERATION,
 782                   "%s(no buffer bound to GL_ELEMENT_ARRAY_BUFFER)", name);
 783       return GL_FALSE;
 784    }
 785
 786    return valid_draw_indirect(ctx, mode, indirect, size, name);
 787 }
 788
 789 static inline GLboolean
 790 valid_draw_indirect_multi(struct gl_context *ctx,
 791                           GLsizei primcount, GLsizei stride,
 792                           const char *name)
 793 {
 794
 795    /* From the ARB_multi_draw_indirect specification:
 796     * "INVALID_VALUE is generated by MultiDrawArraysIndirect or
 797     *  MultiDrawElementsIndirect if <primcount> is negative."
 798     *
 799     * "<primcount> must be positive, otherwise an INVALID_VALUE error will
 800     *  be generated."
 801     */
 802    if (primcount < 0) {
 803       _mesa_error(ctx, GL_INVALID_VALUE, "%s(primcount < 0)", name);
 804       return GL_FALSE;
 805    }
 806
 807
 808    /* From the ARB_multi_draw_indirect specification:
 809     * "<stride> must be a multiple of four, otherwise an INVALID_VALUE
 810     *  error is generated."
 811     */
 812    if (stride % 4) {
 813       _mesa_error(ctx, GL_INVALID_VALUE, "%s(stride %% 4)", name);
 814       return GL_FALSE;
 815    }
 816
 817    return GL_TRUE;
 818 }
 819
 820 GLboolean
 821 _mesa_validate_DrawArraysIndirect(struct gl_context *ctx,
 822                                   GLenum mode,
 823                                   const GLvoid *indirect)
 824 {
 825    const unsigned drawArraysNumParams = 4;
 826
 827    FLUSH_CURRENT(ctx, 0);
 828
 829    return valid_draw_indirect(ctx, mode,
 830                               indirect, drawArraysNumParams * sizeof(GLuint),
 831                               "glDrawArraysIndirect");
 832 }
 833
 834 GLboolean
 835 _mesa_validate_DrawElementsIndirect(struct gl_context *ctx,
 836                                     GLenum mode, GLenum type,
 837                                     const GLvoid *indirect)
 838 {
 839    const unsigned drawElementsNumParams = 5;
 840
 841    FLUSH_CURRENT(ctx, 0);
 842
 843    return valid_draw_indirect_elements(ctx, mode, type,
 844                                        indirect, drawElementsNumParams * sizeof(GLuint),
 845                                        "glDrawElementsIndirect");
 846 }
 847
 848 GLboolean
 849 _mesa_validate_MultiDrawArraysIndirect(struct gl_context *ctx,
 850                                        GLenum mode,
 851                                        const GLvoid *indirect,
 852                                        GLsizei primcount, GLsizei stride)
 853 {
 854    GLsizeiptr size = 0;
 855    const unsigned drawArraysNumParams = 4;
 856
 857    FLUSH_CURRENT(ctx, 0);
 858
 859    /* caller has converted stride==0 to drawArraysNumParams * sizeof(GLuint) */
 860    assert(stride != 0);
 861
 862    if (!valid_draw_indirect_multi(ctx, primcount, stride,
 863                                   "glMultiDrawArraysIndirect"))
 864       return GL_FALSE;
 865
 866    /* number of bytes of the indirect buffer which will be read */
 867    size = primcount
 868       ? (primcount - 1) * stride + drawArraysNumParams * sizeof(GLuint)
 869       : 0;
 870
 871    if (!valid_draw_indirect(ctx, mode, indirect, size,
 872                             "glMultiDrawArraysIndirect"))
 873       return GL_FALSE;
 874
 875    return GL_TRUE;
 876 }
 877
 878 GLboolean
 879 _mesa_validate_MultiDrawElementsIndirect(struct gl_context *ctx,
 880                                          GLenum mode, GLenum type,
 881                                          const GLvoid *indirect,
 882                                          GLsizei primcount, GLsizei stride)
 883 {
 884    GLsizeiptr size = 0;
 885    const unsigned drawElementsNumParams = 5;
 886
 887    FLUSH_CURRENT(ctx, 0);
 888
 889    /* caller has converted stride==0 to drawElementsNumParams * sizeof(GLuint) */
 890    assert(stride != 0);
 891
 892    if (!valid_draw_indirect_multi(ctx, primcount, stride,
 893                                   "glMultiDrawElementsIndirect"))
 894       return GL_FALSE;
 895
 896    /* number of bytes of the indirect buffer which will be read */
 897    size = primcount
 898       ? (primcount - 1) * stride + drawElementsNumParams * sizeof(GLuint)
 899       : 0;
 900
 901    if (!valid_draw_indirect_elements(ctx, mode, type,
 902                                      indirect, size,
 903                                      "glMultiDrawElementsIndirect"))
 904       return GL_FALSE;
 905
 906    return GL_TRUE;
 907 }
 908
 909 static bool
 910 check_valid_to_compute(struct gl_context *ctx, const char *function)
 911 {
 912    struct gl_shader_program *prog;
 913
 914    if (!_mesa_has_compute_shaders(ctx)) {
 915       _mesa_error(ctx, GL_INVALID_OPERATION,
 916                   "unsupported function (%s) called",
 917                   function);
 918       return false;
 919    }
 920
 921    /* From the OpenGL 4.3 Core Specification, Chapter 19, Compute Shaders:
 922     *
 923     * "An INVALID_OPERATION error is generated if there is no active program
 924     *  for the compute shader stage."
 925     */
 926    prog = ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE];
 927    if (prog == NULL || prog->_LinkedShaders[MESA_SHADER_COMPUTE] == NULL) {
 928       _mesa_error(ctx, GL_INVALID_OPERATION,
 929                   "%s(no active compute shader)",
 930                   function);
 931       return false;
 932    }
 933
 934    return true;
 935 }
 936
 937 GLboolean
 938 _mesa_validate_DispatchCompute(struct gl_context *ctx,
 939                                const GLuint *num_groups)
 940 {
 941    int i;
 942    FLUSH_CURRENT(ctx, 0);
 943
 944    if (!check_valid_to_compute(ctx, "glDispatchCompute"))
 945       return GL_FALSE;
 946
 947    for (i = 0; i < 3; i++) {
 948       /* From the OpenGL 4.3 Core Specification, Chapter 19, Compute Shaders:
 949        *
 950        * "An INVALID_VALUE error is generated if any of num_groups_x,
 951        *  num_groups_y and num_groups_z are greater than or equal to the
 952        *  maximum work group count for the corresponding dimension."
 953        *
 954        * However, the "or equal to" portions appears to be a specification
 955        * bug. In all other areas, the specification appears to indicate that
 956        * the number of workgroups can match the MAX_COMPUTE_WORK_GROUP_COUNT
 957        * value. For example, under DispatchComputeIndirect:
 958        *
 959        * "If any of num_groups_x, num_groups_y or num_groups_z is greater than
 960        *  the value of MAX_COMPUTE_WORK_GROUP_COUNT for the corresponding
 961        *  dimension then the results are undefined."
 962        *
 963        * Additionally, the OpenGLES 3.1 specification does not contain "or
 964        * equal to" as an error condition.
 965        */
 966       if (num_groups[i] > ctx->Const.MaxComputeWorkGroupCount[i]) {
 967          _mesa_error(ctx, GL_INVALID_VALUE,
 968                      "glDispatchCompute(num_groups_%c)", 'x' + i);
 969          return GL_FALSE;
 970       }
 971    }
 972
 973    return GL_TRUE;
 974 }
 975
 976 static GLboolean
 977 valid_dispatch_indirect(struct gl_context *ctx,
 978                         GLintptr indirect,
 979                         GLsizei size, const char *name)
 980 {
 981    GLintptr end = (GLintptr)indirect + size;
 982
 983    if (!check_valid_to_compute(ctx, name))
 984       return GL_FALSE;
 985
 986    /* From the OpenGL 4.3 Core Specification, Chapter 19, Compute Shaders:
 987     *
 988     * "An INVALID_VALUE error is generated if indirect is negative or is not a
 989     *  multiple of four."
 990     */
 991    if ((GLintptr)indirect & (sizeof(GLuint) - 1)) {
 992       _mesa_error(ctx, GL_INVALID_VALUE,
 993                   "%s(indirect is not aligned)", name);
 994       return GL_FALSE;
 995    }
 996
 997    if ((GLintptr)indirect < 0) {
 998       _mesa_error(ctx, GL_INVALID_VALUE,
 999                   "%s(indirect is less than zero)", name);
1000       return GL_FALSE;
1001    }
1002
1003    /* From the OpenGL 4.3 Core Specification, Chapter 19, Compute Shaders:
1004     *
1005     * "An INVALID_OPERATION error is generated if no buffer is bound to the
1006     *  DRAW_INDIRECT_BUFFER binding, or if the command would source data
1007     *  beyond the end of the buffer object."
1008     */
1009    if (!_mesa_is_bufferobj(ctx->DispatchIndirectBuffer)) {
1010       _mesa_error(ctx, GL_INVALID_OPERATION,
1011                   "%s: no buffer bound to DISPATCH_INDIRECT_BUFFER", name);
1012       return GL_FALSE;
1013    }
1014
1015    if (_mesa_check_disallowed_mapping(ctx->DispatchIndirectBuffer)) {
1016       _mesa_error(ctx, GL_INVALID_OPERATION,
1017                   "%s(DISPATCH_INDIRECT_BUFFER is mapped)", name);
1018       return GL_FALSE;
1019    }
1020
1021    if (ctx->DispatchIndirectBuffer->Size < end) {
1022       _mesa_error(ctx, GL_INVALID_OPERATION,
1023                   "%s(DISPATCH_INDIRECT_BUFFER too small)", name);
1024       return GL_FALSE;
1025    }
1026
1027    return GL_TRUE;
1028 }
1029
1030 GLboolean
1031 _mesa_validate_DispatchComputeIndirect(struct gl_context *ctx,
1032                                        GLintptr indirect)
1033 {
1034    FLUSH_CURRENT(ctx, 0);
1035
1036    return valid_dispatch_indirect(ctx, indirect, 3 * sizeof(GLuint),
1037                                   "glDispatchComputeIndirect");
1038 }