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 OpenGL 4.5 specification, section 11.3.1:
 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    /* From the GL 4.5 specification, page 429:
 669     * "An INVALID_VALUE error is generated if id is not the name of a
 670     *  transform feedback object."
 671     */
 672    if (!obj->EverBound) {
 673       _mesa_error(ctx, GL_INVALID_VALUE, "glDrawTransformFeedback*(name)");
 674       return GL_FALSE;
 675    }
 676
 677    if (stream >= ctx->Const.MaxVertexStreams) {
 678       _mesa_error(ctx, GL_INVALID_VALUE,
 679                   "glDrawTransformFeedbackStream*(index>=MaxVertexStream)");
 680       return GL_FALSE;
 681    }
 682
 683    if (!obj->EndedAnytime) {
 684       _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawTransformFeedback*");
 685       return GL_FALSE;
 686    }
 687
 688    if (numInstances <= 0) {
 689       if (numInstances < 0)
 690          _mesa_error(ctx, GL_INVALID_VALUE,
 691                      "glDrawTransformFeedback*Instanced(numInstances=%d)",
 692                      numInstances);
 693       return GL_FALSE;
 694    }
 695
 696    if (!check_valid_to_render(ctx, "glDrawTransformFeedback*")) {
 697       return GL_FALSE;
 698    }
 699
 700    return GL_TRUE;
 701 }
 702
 703 static GLboolean
 704 valid_draw_indirect(struct gl_context *ctx,
 705                     GLenum mode, const GLvoid *indirect,
 706                     GLsizei size, const char *name)
 707 {
 708    const uint64_t end = (uint64_t) (uintptr_t) indirect + size;
 709
 710    /* OpenGL ES 3.1 spec. section 10.5:
 711     *
 712     *      "DrawArraysIndirect requires that all data sourced for the
 713     *      command, including the DrawArraysIndirectCommand
 714     *      structure,  be in buffer objects,  and may not be called when
 715     *      the default vertex array object is bound."
 716     */
 717    if (ctx->Array.VAO == ctx->Array.DefaultVAO) {
 718       _mesa_error(ctx, GL_INVALID_OPERATION, "(no VAO bound)");
 719       return GL_FALSE;
 720    }
 721
 722    /* From OpenGL ES 3.1 spec. section 10.5:
 723     *     "An INVALID_OPERATION error is generated if zero is bound to
 724     *     VERTEX_ARRAY_BINDING, DRAW_INDIRECT_BUFFER or to any enabled
 725     *     vertex array."
 726     *
 727     * Here we check that for each enabled vertex array we have a vertex
 728     * buffer bound.
 729     */
 730    if (_mesa_is_gles31(ctx) &&
 731        ctx->Array.VAO->_Enabled != ctx->Array.VAO->VertexAttribBufferMask) {
 732       _mesa_error(ctx, GL_INVALID_OPERATION, "%s(No VBO bound)", name);
 733       return GL_FALSE;
 734    }
 735
 736    if (!_mesa_valid_prim_mode(ctx, mode, name))
 737       return GL_FALSE;
 738
 739    /* OpenGL ES 3.1 specification, section 10.5:
 740     *
 741     *      "An INVALID_OPERATION error is generated if
 742     *      transform feedback is active and not paused."
 743     */
 744    if (_mesa_is_gles31(ctx) && _mesa_is_xfb_active_and_unpaused(ctx)) {
 745       _mesa_error(ctx, GL_INVALID_OPERATION,
 746                   "%s(TransformFeedback is active and not paused)", name);
 747    }
 748
 749    /* From OpenGL version 4.4. section 10.5
 750     * and OpenGL ES 3.1, section 10.6:
 751     *
 752     *      "An INVALID_VALUE error is generated if indirect is not a
 753     *       multiple of the size, in basic machine units, of uint."
 754     */
 755    if ((GLsizeiptr)indirect & (sizeof(GLuint) - 1)) {
 756       _mesa_error(ctx, GL_INVALID_VALUE,
 757                   "%s(indirect is not aligned)", name);
 758       return GL_FALSE;
 759    }
 760
 761    if (!_mesa_is_bufferobj(ctx->DrawIndirectBuffer)) {
 762       _mesa_error(ctx, GL_INVALID_OPERATION,
 763                   "%s: no buffer bound to DRAW_INDIRECT_BUFFER", name);
 764       return GL_FALSE;
 765    }
 766
 767    if (_mesa_check_disallowed_mapping(ctx->DrawIndirectBuffer)) {
 768       _mesa_error(ctx, GL_INVALID_OPERATION,
 769                   "%s(DRAW_INDIRECT_BUFFER is mapped)", name);
 770       return GL_FALSE;
 771    }
 772
 773    /* From the ARB_draw_indirect specification:
 774     * "An INVALID_OPERATION error is generated if the commands source data
 775     *  beyond the end of the buffer object [...]"
 776     */
 777    if (ctx->DrawIndirectBuffer->Size < end) {
 778       _mesa_error(ctx, GL_INVALID_OPERATION,
 779                   "%s(DRAW_INDIRECT_BUFFER too small)", name);
 780       return GL_FALSE;
 781    }
 782
 783    if (!check_valid_to_render(ctx, name))
 784       return GL_FALSE;
 785
 786    return GL_TRUE;
 787 }
 788
 789 static inline GLboolean
 790 valid_draw_indirect_elements(struct gl_context *ctx,
 791                              GLenum mode, GLenum type, const GLvoid *indirect,
 792                              GLsizeiptr size, const char *name)
 793 {
 794    if (!valid_elements_type(ctx, type, name))
 795       return GL_FALSE;
 796
 797    /*
 798     * Unlike regular DrawElementsInstancedBaseVertex commands, the indices
 799     * may not come from a client array and must come from an index buffer.
 800     * If no element array buffer is bound, an INVALID_OPERATION error is
 801     * generated.
 802     */
 803    if (!_mesa_is_bufferobj(ctx->Array.VAO->IndexBufferObj)) {
 804       _mesa_error(ctx, GL_INVALID_OPERATION,
 805                   "%s(no buffer bound to GL_ELEMENT_ARRAY_BUFFER)", name);
 806       return GL_FALSE;
 807    }
 808
 809    return valid_draw_indirect(ctx, mode, indirect, size, name);
 810 }
 811
 812 static inline GLboolean
 813 valid_draw_indirect_multi(struct gl_context *ctx,
 814                           GLsizei primcount, GLsizei stride,
 815                           const char *name)
 816 {
 817
 818    /* From the ARB_multi_draw_indirect specification:
 819     * "INVALID_VALUE is generated by MultiDrawArraysIndirect or
 820     *  MultiDrawElementsIndirect if <primcount> is negative."
 821     *
 822     * "<primcount> must be positive, otherwise an INVALID_VALUE error will
 823     *  be generated."
 824     */
 825    if (primcount < 0) {
 826       _mesa_error(ctx, GL_INVALID_VALUE, "%s(primcount < 0)", name);
 827       return GL_FALSE;
 828    }
 829
 830
 831    /* From the ARB_multi_draw_indirect specification:
 832     * "<stride> must be a multiple of four, otherwise an INVALID_VALUE
 833     *  error is generated."
 834     */
 835    if (stride % 4) {
 836       _mesa_error(ctx, GL_INVALID_VALUE, "%s(stride %% 4)", name);
 837       return GL_FALSE;
 838    }
 839
 840    return GL_TRUE;
 841 }
 842
 843 GLboolean
 844 _mesa_validate_DrawArraysIndirect(struct gl_context *ctx,
 845                                   GLenum mode,
 846                                   const GLvoid *indirect)
 847 {
 848    const unsigned drawArraysNumParams = 4;
 849
 850    FLUSH_CURRENT(ctx, 0);
 851
 852    return valid_draw_indirect(ctx, mode,
 853                               indirect, drawArraysNumParams * sizeof(GLuint),
 854                               "glDrawArraysIndirect");
 855 }
 856
 857 GLboolean
 858 _mesa_validate_DrawElementsIndirect(struct gl_context *ctx,
 859                                     GLenum mode, GLenum type,
 860                                     const GLvoid *indirect)
 861 {
 862    const unsigned drawElementsNumParams = 5;
 863
 864    FLUSH_CURRENT(ctx, 0);
 865
 866    return valid_draw_indirect_elements(ctx, mode, type,
 867                                        indirect, drawElementsNumParams * sizeof(GLuint),
 868                                        "glDrawElementsIndirect");
 869 }
 870
 871 GLboolean
 872 _mesa_validate_MultiDrawArraysIndirect(struct gl_context *ctx,
 873                                        GLenum mode,
 874                                        const GLvoid *indirect,
 875                                        GLsizei primcount, GLsizei stride)
 876 {
 877    GLsizeiptr size = 0;
 878    const unsigned drawArraysNumParams = 4;
 879
 880    FLUSH_CURRENT(ctx, 0);
 881
 882    /* caller has converted stride==0 to drawArraysNumParams * sizeof(GLuint) */
 883    assert(stride != 0);
 884
 885    if (!valid_draw_indirect_multi(ctx, primcount, stride,
 886                                   "glMultiDrawArraysIndirect"))
 887       return GL_FALSE;
 888
 889    /* number of bytes of the indirect buffer which will be read */
 890    size = primcount
 891       ? (primcount - 1) * stride + drawArraysNumParams * sizeof(GLuint)
 892       : 0;
 893
 894    if (!valid_draw_indirect(ctx, mode, indirect, size,
 895                             "glMultiDrawArraysIndirect"))
 896       return GL_FALSE;
 897
 898    return GL_TRUE;
 899 }
 900
 901 GLboolean
 902 _mesa_validate_MultiDrawElementsIndirect(struct gl_context *ctx,
 903                                          GLenum mode, GLenum type,
 904                                          const GLvoid *indirect,
 905                                          GLsizei primcount, GLsizei stride)
 906 {
 907    GLsizeiptr size = 0;
 908    const unsigned drawElementsNumParams = 5;
 909
 910    FLUSH_CURRENT(ctx, 0);
 911
 912    /* caller has converted stride==0 to drawElementsNumParams * sizeof(GLuint) */
 913    assert(stride != 0);
 914
 915    if (!valid_draw_indirect_multi(ctx, primcount, stride,
 916                                   "glMultiDrawElementsIndirect"))
 917       return GL_FALSE;
 918
 919    /* number of bytes of the indirect buffer which will be read */
 920    size = primcount
 921       ? (primcount - 1) * stride + drawElementsNumParams * sizeof(GLuint)
 922       : 0;
 923
 924    if (!valid_draw_indirect_elements(ctx, mode, type,
 925                                      indirect, size,
 926                                      "glMultiDrawElementsIndirect"))
 927       return GL_FALSE;
 928
 929    return GL_TRUE;
 930 }
 931
 932 static GLboolean
 933 valid_draw_indirect_parameters(struct gl_context *ctx,
 934                                const char *name,
 935                                GLintptr drawcount)
 936 {
 937    /* From the ARB_indirect_parameters specification:
 938     * "INVALID_VALUE is generated by MultiDrawArraysIndirectCountARB or
 939     *  MultiDrawElementsIndirectCountARB if <drawcount> is not a multiple of
 940     *  four."
 941     */
 942    if (drawcount & 3) {
 943       _mesa_error(ctx, GL_INVALID_VALUE,
 944                   "%s(drawcount is not a multiple of 4)", name);
 945       return GL_FALSE;
 946    }
 947
 948    /* From the ARB_indirect_parameters specification:
 949     * "INVALID_OPERATION is generated by MultiDrawArraysIndirectCountARB or
 950     *  MultiDrawElementsIndirectCountARB if no buffer is bound to the
 951     *  PARAMETER_BUFFER_ARB binding point."
 952     */
 953    if (!_mesa_is_bufferobj(ctx->ParameterBuffer)) {
 954       _mesa_error(ctx, GL_INVALID_OPERATION,
 955                   "%s: no buffer bound to PARAMETER_BUFFER", name);
 956       return GL_FALSE;
 957    }
 958
 959    if (_mesa_check_disallowed_mapping(ctx->ParameterBuffer)) {
 960       _mesa_error(ctx, GL_INVALID_OPERATION,
 961                   "%s(PARAMETER_BUFFER is mapped)", name);
 962       return GL_FALSE;
 963    }
 964
 965    /* From the ARB_indirect_parameters specification:
 966     * "INVALID_OPERATION is generated by MultiDrawArraysIndirectCountARB or
 967     *  MultiDrawElementsIndirectCountARB if reading a <sizei> typed value
 968     *  from the buffer bound to the PARAMETER_BUFFER_ARB target at the offset
 969     *  specified by <drawcount> would result in an out-of-bounds access."
 970     */
 971    if (ctx->ParameterBuffer->Size < drawcount + sizeof(GLsizei)) {
 972       _mesa_error(ctx, GL_INVALID_OPERATION,
 973                   "%s(PARAMETER_BUFFER too small)", name);
 974       return GL_FALSE;
 975    }
 976
 977    return GL_TRUE;
 978 }
 979
 980 GLboolean
 981 _mesa_validate_MultiDrawArraysIndirectCount(struct gl_context *ctx,
 982                                             GLenum mode,
 983                                             GLintptr indirect,
 984                                             GLintptr drawcount,
 985                                             GLsizei maxdrawcount,
 986                                             GLsizei stride)
 987 {
 988    GLsizeiptr size = 0;
 989    const unsigned drawArraysNumParams = 4;
 990
 991    FLUSH_CURRENT(ctx, 0);
 992
 993    /* caller has converted stride==0 to drawArraysNumParams * sizeof(GLuint) */
 994    assert(stride != 0);
 995
 996    if (!valid_draw_indirect_multi(ctx, maxdrawcount, stride,
 997                                   "glMultiDrawArraysIndirectCountARB"))
 998       return GL_FALSE;
 999
1000    /* number of bytes of the indirect buffer which will be read */
1001    size = maxdrawcount
1002       ? (maxdrawcount - 1) * stride + drawArraysNumParams * sizeof(GLuint)
1003       : 0;
1004
1005    if (!valid_draw_indirect(ctx, mode, (void *)indirect, size,
1006                             "glMultiDrawArraysIndirectCountARB"))
1007       return GL_FALSE;
1008
1009    return valid_draw_indirect_parameters(
1010          ctx, "glMultiDrawArraysIndirectCountARB", drawcount);
1011 }
1012
1013 GLboolean
1014 _mesa_validate_MultiDrawElementsIndirectCount(struct gl_context *ctx,
1015                                               GLenum mode, GLenum type,
1016                                               GLintptr indirect,
1017                                               GLintptr drawcount,
1018                                               GLsizei maxdrawcount,
1019                                               GLsizei stride)
1020 {
1021    GLsizeiptr size = 0;
1022    const unsigned drawElementsNumParams = 5;
1023
1024    FLUSH_CURRENT(ctx, 0);
1025
1026    /* caller has converted stride==0 to drawElementsNumParams * sizeof(GLuint) */
1027    assert(stride != 0);
1028
1029    if (!valid_draw_indirect_multi(ctx, maxdrawcount, stride,
1030                                   "glMultiDrawElementsIndirectCountARB"))
1031       return GL_FALSE;
1032
1033    /* number of bytes of the indirect buffer which will be read */
1034    size = maxdrawcount
1035       ? (maxdrawcount - 1) * stride + drawElementsNumParams * sizeof(GLuint)
1036       : 0;
1037
1038    if (!valid_draw_indirect_elements(ctx, mode, type,
1039                                      (void *)indirect, size,
1040                                      "glMultiDrawElementsIndirectCountARB"))
1041       return GL_FALSE;
1042
1043    return valid_draw_indirect_parameters(
1044          ctx, "glMultiDrawElementsIndirectCountARB", drawcount);
1045 }
1046
1047 static bool
1048 check_valid_to_compute(struct gl_context *ctx, const char *function)
1049 {
1050    struct gl_shader_program *prog;
1051
1052    if (!_mesa_has_compute_shaders(ctx)) {
1053       _mesa_error(ctx, GL_INVALID_OPERATION,
1054                   "unsupported function (%s) called",
1055                   function);
1056       return false;
1057    }
1058
1059    /* From the OpenGL 4.3 Core Specification, Chapter 19, Compute Shaders:
1060     *
1061     * "An INVALID_OPERATION error is generated if there is no active program
1062     *  for the compute shader stage."
1063     */
1064    prog = ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE];
1065    if (prog == NULL || prog->_LinkedShaders[MESA_SHADER_COMPUTE] == NULL) {
1066       _mesa_error(ctx, GL_INVALID_OPERATION,
1067                   "%s(no active compute shader)",
1068                   function);
1069       return false;
1070    }
1071
1072    return true;
1073 }
1074
1075 GLboolean
1076 _mesa_validate_DispatchCompute(struct gl_context *ctx,
1077                                const GLuint *num_groups)
1078 {
1079    int i;
1080    FLUSH_CURRENT(ctx, 0);
1081
1082    if (!check_valid_to_compute(ctx, "glDispatchCompute"))
1083       return GL_FALSE;
1084
1085    for (i = 0; i < 3; i++) {
1086       /* From the OpenGL 4.3 Core Specification, Chapter 19, Compute Shaders:
1087        *
1088        * "An INVALID_VALUE error is generated if any of num_groups_x,
1089        *  num_groups_y and num_groups_z are greater than or equal to the
1090        *  maximum work group count for the corresponding dimension."
1091        *
1092        * However, the "or equal to" portions appears to be a specification
1093        * bug. In all other areas, the specification appears to indicate that
1094        * the number of workgroups can match the MAX_COMPUTE_WORK_GROUP_COUNT
1095        * value. For example, under DispatchComputeIndirect:
1096        *
1097        * "If any of num_groups_x, num_groups_y or num_groups_z is greater than
1098        *  the value of MAX_COMPUTE_WORK_GROUP_COUNT for the corresponding
1099        *  dimension then the results are undefined."
1100        *
1101        * Additionally, the OpenGLES 3.1 specification does not contain "or
1102        * equal to" as an error condition.
1103        */
1104       if (num_groups[i] > ctx->Const.MaxComputeWorkGroupCount[i]) {
1105          _mesa_error(ctx, GL_INVALID_VALUE,
1106                      "glDispatchCompute(num_groups_%c)", 'x' + i);
1107          return GL_FALSE;
1108       }
1109    }
1110
1111    return GL_TRUE;
1112 }
1113
1114 static GLboolean
1115 valid_dispatch_indirect(struct gl_context *ctx,
1116                         GLintptr indirect,
1117                         GLsizei size, const char *name)
1118 {
1119    const uint64_t end = (uint64_t) indirect + size;
1120
1121    if (!check_valid_to_compute(ctx, name))
1122       return GL_FALSE;
1123
1124    /* From the OpenGL 4.3 Core Specification, Chapter 19, Compute Shaders:
1125     *
1126     * "An INVALID_VALUE error is generated if indirect is negative or is not a
1127     *  multiple of four."
1128     */
1129    if (indirect & (sizeof(GLuint) - 1)) {
1130       _mesa_error(ctx, GL_INVALID_VALUE,
1131                   "%s(indirect is not aligned)", name);
1132       return GL_FALSE;
1133    }
1134
1135    if (indirect < 0) {
1136       _mesa_error(ctx, GL_INVALID_VALUE,
1137                   "%s(indirect is less than zero)", name);
1138       return GL_FALSE;
1139    }
1140
1141    /* From the OpenGL 4.3 Core Specification, Chapter 19, Compute Shaders:
1142     *
1143     * "An INVALID_OPERATION error is generated if no buffer is bound to the
1144     *  DRAW_INDIRECT_BUFFER binding, or if the command would source data
1145     *  beyond the end of the buffer object."
1146     */
1147    if (!_mesa_is_bufferobj(ctx->DispatchIndirectBuffer)) {
1148       _mesa_error(ctx, GL_INVALID_OPERATION,
1149                   "%s: no buffer bound to DISPATCH_INDIRECT_BUFFER", name);
1150       return GL_FALSE;
1151    }
1152
1153    if (_mesa_check_disallowed_mapping(ctx->DispatchIndirectBuffer)) {
1154       _mesa_error(ctx, GL_INVALID_OPERATION,
1155                   "%s(DISPATCH_INDIRECT_BUFFER is mapped)", name);
1156       return GL_FALSE;
1157    }
1158
1159    if (ctx->DispatchIndirectBuffer->Size < end) {
1160       _mesa_error(ctx, GL_INVALID_OPERATION,
1161                   "%s(DISPATCH_INDIRECT_BUFFER too small)", name);
1162       return GL_FALSE;
1163    }
1164
1165    return GL_TRUE;
1166 }
1167
1168 GLboolean
1169 _mesa_validate_DispatchComputeIndirect(struct gl_context *ctx,
1170                                        GLintptr indirect)
1171 {
1172    FLUSH_CURRENT(ctx, 0);
1173
1174    return valid_dispatch_indirect(ctx, indirect, 3 * sizeof(GLuint),
1175                                   "glDispatchComputeIndirect");
1176 }