mesa/varray: make use of dispatch KHR_no_error support

Make use of dispatch KHR_no_error support for varray functions.

Reviewed-by: Nicolai Hähnle <[email protected]>

1 files changed, 319 insertions, 173 deletions

diff --git a/src/mesa/main/varray.c b/src/mesa/main/varray.c
index 709f6d4ec94..eda86ec6a82 100644
--- a/src/mesa/main/varray.c
+++ b/src/mesa/main/varray.c
@@ -577,6 +577,17 @@ update_array(struct gl_context *ctx,
                             effectiveStride);
 }
 
+void GLAPIENTRY
+_mesa_VertexPointer_no_error(GLint size, GLenum type, GLsizei stride,
+                             const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+
+   update_array(ctx, VERT_ATTRIB_POS, GL_RGBA, 4, size, type, stride,
+                GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
 
 void GLAPIENTRY
 _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
@@ -586,20 +597,18 @@ _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
    FLUSH_VERTICES(ctx, 0);
 
    GLenum format = GL_RGBA;
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      GLbitfield legalTypes = (ctx->API == API_OPENGLES)
-         ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
-         : (SHORT_BIT | INT_BIT | FLOAT_BIT |
-            DOUBLE_BIT | HALF_BIT |
-            UNSIGNED_INT_2_10_10_10_REV_BIT |
-            INT_2_10_10_10_REV_BIT);
-
-      if (!validate_array_and_format(ctx, "glVertexPointer", VERT_ATTRIB_POS,
-                                     legalTypes, 2, 4, size, type, stride,
-                                     GL_FALSE, GL_FALSE, GL_FALSE, format,
-                                     ptr, ctx->Array.VAO))
-         return;
-   }
+   GLbitfield legalTypes = (ctx->API == API_OPENGLES)
+      ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
+      : (SHORT_BIT | INT_BIT | FLOAT_BIT |
+         DOUBLE_BIT | HALF_BIT |
+         UNSIGNED_INT_2_10_10_10_REV_BIT |
+         INT_2_10_10_10_REV_BIT);
+
+   if (!validate_array_and_format(ctx, "glVertexPointer", VERT_ATTRIB_POS,
+                                  legalTypes, 2, 4, size, type, stride,
+                                  GL_FALSE, GL_FALSE, GL_FALSE, format,
+                                  ptr, ctx->Array.VAO))
+      return;
 
    update_array(ctx, VERT_ATTRIB_POS, format, 4, size, type, stride,
                 GL_FALSE, GL_FALSE, GL_FALSE, ptr);
@@ -607,6 +616,17 @@ _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
 
 
 void GLAPIENTRY
+_mesa_NormalPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+
+   update_array(ctx, VERT_ATTRIB_NORMAL, GL_RGBA, 3, 3, type, stride, GL_TRUE,
+                GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
 _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -614,20 +634,18 @@ _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
    FLUSH_VERTICES(ctx, 0);
 
    GLenum format = GL_RGBA;
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
-         ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
-         : (BYTE_BIT | SHORT_BIT | INT_BIT |
-            HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
-            UNSIGNED_INT_2_10_10_10_REV_BIT |
-            INT_2_10_10_10_REV_BIT);
-
-      if (!validate_array_and_format(ctx, "glNormalPointer",
-                                     VERT_ATTRIB_NORMAL, legalTypes, 3, 3, 3,
-                                     type, stride, GL_TRUE, GL_FALSE,
-                                     GL_FALSE, format, ptr, ctx->Array.VAO))
-         return;
-   }
+   const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
+      ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
+      : (BYTE_BIT | SHORT_BIT | INT_BIT |
+         HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+         UNSIGNED_INT_2_10_10_10_REV_BIT |
+         INT_2_10_10_10_REV_BIT);
+
+   if (!validate_array_and_format(ctx, "glNormalPointer",
+                                  VERT_ATTRIB_NORMAL, legalTypes, 3, 3, 3,
+                                  type, stride, GL_TRUE, GL_FALSE,
+                                  GL_FALSE, format, ptr, ctx->Array.VAO))
+      return;
 
    update_array(ctx, VERT_ATTRIB_NORMAL, format, 3, 3, type, stride, GL_TRUE,
                 GL_FALSE, GL_FALSE, ptr);
@@ -635,6 +653,19 @@ _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
 
 
 void GLAPIENTRY
+_mesa_ColorPointer_no_error(GLint size, GLenum type, GLsizei stride,
+                            const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+
+   GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+   update_array(ctx, VERT_ATTRIB_COLOR0, format, BGRA_OR_4, size,
+                type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
 _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -643,23 +674,21 @@ _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
    FLUSH_VERTICES(ctx, 0);
 
    GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
-         ? (UNSIGNED_BYTE_BIT | HALF_BIT | FLOAT_BIT | FIXED_ES_BIT)
-         : (BYTE_BIT | UNSIGNED_BYTE_BIT |
-            SHORT_BIT | UNSIGNED_SHORT_BIT |
-            INT_BIT | UNSIGNED_INT_BIT |
-            HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
-            UNSIGNED_INT_2_10_10_10_REV_BIT |
-            INT_2_10_10_10_REV_BIT);
-
-      if (!validate_array_and_format(ctx, "glColorPointer",
-                                     VERT_ATTRIB_COLOR0, legalTypes, sizeMin,
-                                     BGRA_OR_4, size, type, stride, GL_TRUE,
-                                     GL_FALSE, GL_FALSE, format, ptr,
-                                     ctx->Array.VAO))
-         return;
-   }
+   const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
+      ? (UNSIGNED_BYTE_BIT | HALF_BIT | FLOAT_BIT | FIXED_ES_BIT)
+      : (BYTE_BIT | UNSIGNED_BYTE_BIT |
+         SHORT_BIT | UNSIGNED_SHORT_BIT |
+         INT_BIT | UNSIGNED_INT_BIT |
+         HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+         UNSIGNED_INT_2_10_10_10_REV_BIT |
+         INT_2_10_10_10_REV_BIT);
+
+   if (!validate_array_and_format(ctx, "glColorPointer",
+                                  VERT_ATTRIB_COLOR0, legalTypes, sizeMin,
+                                  BGRA_OR_4, size, type, stride, GL_TRUE,
+                                  GL_FALSE, GL_FALSE, format, ptr,
+                                  ctx->Array.VAO))
+      return;
 
    update_array(ctx, VERT_ATTRIB_COLOR0, format, BGRA_OR_4, size,
                 type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
@@ -667,6 +696,17 @@ _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
 
 
 void GLAPIENTRY
+_mesa_FogCoordPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+
+   update_array(ctx, VERT_ATTRIB_FOG, GL_RGBA, 1, 1, type, stride, GL_FALSE,
+                GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
 _mesa_FogCoordPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -674,15 +714,13 @@ _mesa_FogCoordPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
    FLUSH_VERTICES(ctx, 0);
 
    GLenum format = GL_RGBA;
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      const GLbitfield legalTypes = (HALF_BIT | FLOAT_BIT | DOUBLE_BIT);
+   const GLbitfield legalTypes = (HALF_BIT | FLOAT_BIT | DOUBLE_BIT);
 
-      if (!validate_array_and_format(ctx, "glFogCoordPointer",
-                                     VERT_ATTRIB_FOG, legalTypes, 1, 1, 1,
-                                     type, stride, GL_FALSE, GL_FALSE,
-                                     GL_FALSE, format, ptr, ctx->Array.VAO))
-         return;
-   }
+   if (!validate_array_and_format(ctx, "glFogCoordPointer",
+                                  VERT_ATTRIB_FOG, legalTypes, 1, 1, 1,
+                                  type, stride, GL_FALSE, GL_FALSE,
+                                  GL_FALSE, format, ptr, ctx->Array.VAO))
+      return;
 
    update_array(ctx, VERT_ATTRIB_FOG, format, 1, 1, type, stride, GL_FALSE,
                 GL_FALSE, GL_FALSE, ptr);
@@ -690,6 +728,17 @@ _mesa_FogCoordPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
 
 
 void GLAPIENTRY
+_mesa_IndexPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+
+   update_array(ctx, VERT_ATTRIB_COLOR_INDEX, GL_RGBA, 1, 1, type, stride,
+                GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
 _mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -697,17 +746,15 @@ _mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
    FLUSH_VERTICES(ctx, 0);
 
    GLenum format = GL_RGBA;
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      const GLbitfield legalTypes = (UNSIGNED_BYTE_BIT | SHORT_BIT | INT_BIT |
+   const GLbitfield legalTypes = (UNSIGNED_BYTE_BIT | SHORT_BIT | INT_BIT |
                                      FLOAT_BIT | DOUBLE_BIT);
 
-      if (!validate_array_and_format(ctx, "glIndexPointer",
-                                     VERT_ATTRIB_COLOR_INDEX,
-                                     legalTypes, 1, 1, 1, type, stride,
-                                     GL_FALSE, GL_FALSE, GL_FALSE, format,
-                                     ptr, ctx->Array.VAO))
-         return;
-   }
+   if (!validate_array_and_format(ctx, "glIndexPointer",
+                                  VERT_ATTRIB_COLOR_INDEX,
+                                  legalTypes, 1, 1, 1, type, stride,
+                                  GL_FALSE, GL_FALSE, GL_FALSE, format,
+                                  ptr, ctx->Array.VAO))
+      return;
 
    update_array(ctx, VERT_ATTRIB_COLOR_INDEX, format, 1, 1, type, stride,
                 GL_FALSE, GL_FALSE, GL_FALSE, ptr);
@@ -715,6 +762,19 @@ _mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
 
 
 void GLAPIENTRY
+_mesa_SecondaryColorPointer_no_error(GLint size, GLenum type,
+                                     GLsizei stride, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+
+   GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+   update_array(ctx, VERT_ATTRIB_COLOR1, format, BGRA_OR_4, size, type,
+                stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
 _mesa_SecondaryColorPointer(GLint size, GLenum type,
 			       GLsizei stride, const GLvoid *ptr)
 {
@@ -723,21 +783,19 @@ _mesa_SecondaryColorPointer(GLint size, GLenum type,
    FLUSH_VERTICES(ctx, 0);
 
    GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
-                                     SHORT_BIT | UNSIGNED_SHORT_BIT |
-                                     INT_BIT | UNSIGNED_INT_BIT |
-                                     HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
-                                     UNSIGNED_INT_2_10_10_10_REV_BIT |
-                                     INT_2_10_10_10_REV_BIT);
-
-      if (!validate_array_and_format(ctx, "glSecondaryColorPointer",
-                                     VERT_ATTRIB_COLOR1, legalTypes, 3,
-                                     BGRA_OR_4, size, type, stride,
-                                     GL_TRUE, GL_FALSE, GL_FALSE, format, ptr,
-                                     ctx->Array.VAO))
-         return;
-   }
+   const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
+                                  SHORT_BIT | UNSIGNED_SHORT_BIT |
+                                  INT_BIT | UNSIGNED_INT_BIT |
+                                  HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+                                  UNSIGNED_INT_2_10_10_10_REV_BIT |
+                                  INT_2_10_10_10_REV_BIT);
+
+   if (!validate_array_and_format(ctx, "glSecondaryColorPointer",
+                                  VERT_ATTRIB_COLOR1, legalTypes, 3,
+                                  BGRA_OR_4, size, type, stride,
+                                  GL_TRUE, GL_FALSE, GL_FALSE, format, ptr,
+                                  ctx->Array.VAO))
+      return;
 
    update_array(ctx, VERT_ATTRIB_COLOR1, format, BGRA_OR_4, size, type,
                 stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
@@ -745,6 +803,19 @@ _mesa_SecondaryColorPointer(GLint size, GLenum type,
 
 
 void GLAPIENTRY
+_mesa_TexCoordPointer_no_error(GLint size, GLenum type, GLsizei stride,
+                               const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   const GLuint unit = ctx->Array.ActiveTexture;
+   FLUSH_VERTICES(ctx, 0);
+
+   update_array(ctx, VERT_ATTRIB_TEX(unit), GL_RGBA, 4, size, type,
+                stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
 _mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
                       const GLvoid *ptr)
 {
@@ -755,21 +826,19 @@ _mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
    FLUSH_VERTICES(ctx, 0);
 
    GLenum format = GL_RGBA;
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
-         ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
-         : (SHORT_BIT | INT_BIT |
-            HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
-            UNSIGNED_INT_2_10_10_10_REV_BIT |
-            INT_2_10_10_10_REV_BIT);
-
-      if (!validate_array_and_format(ctx, "glTexCoordPointer",
-                                     VERT_ATTRIB_TEX(unit), legalTypes,
-                                     sizeMin, 4, size, type, stride,
-                                     GL_FALSE, GL_FALSE, GL_FALSE, format, ptr,
-                                     ctx->Array.VAO))
-         return;
-   }
+   const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
+      ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
+      : (SHORT_BIT | INT_BIT |
+         HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+         UNSIGNED_INT_2_10_10_10_REV_BIT |
+         INT_2_10_10_10_REV_BIT);
+
+   if (!validate_array_and_format(ctx, "glTexCoordPointer",
+                                  VERT_ATTRIB_TEX(unit), legalTypes,
+                                  sizeMin, 4, size, type, stride,
+                                  GL_FALSE, GL_FALSE, GL_FALSE, format, ptr,
+                                  ctx->Array.VAO))
+      return;
 
    update_array(ctx, VERT_ATTRIB_TEX(unit), format, 4, size, type,
                 stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
@@ -777,6 +846,19 @@ _mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
 
 
 void GLAPIENTRY
+_mesa_EdgeFlagPointer_no_error(GLsizei stride, const GLvoid *ptr)
+{
+   /* this is the same type that glEdgeFlag uses */
+   const GLboolean integer = GL_FALSE;
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+
+   update_array(ctx, VERT_ATTRIB_EDGEFLAG, GL_RGBA, 1, 1, GL_UNSIGNED_BYTE,
+                stride, GL_FALSE, integer, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
 _mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr)
 {
    /* this is the same type that glEdgeFlag uses */
@@ -786,16 +868,14 @@ _mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr)
    FLUSH_VERTICES(ctx, 0);
 
    GLenum format = GL_RGBA;
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      const GLbitfield legalTypes = UNSIGNED_BYTE_BIT;
+   const GLbitfield legalTypes = UNSIGNED_BYTE_BIT;
 
-      if (!validate_array_and_format(ctx, "glEdgeFlagPointer",
-                                     VERT_ATTRIB_EDGEFLAG, legalTypes,
-                                     1, 1, 1, GL_UNSIGNED_BYTE, stride,
-                                     GL_FALSE, integer, GL_FALSE, format, ptr,
-                                     ctx->Array.VAO))
-         return;
-   }
+   if (!validate_array_and_format(ctx, "glEdgeFlagPointer",
+                                  VERT_ATTRIB_EDGEFLAG, legalTypes,
+                                  1, 1, 1, GL_UNSIGNED_BYTE, stride,
+                                  GL_FALSE, integer, GL_FALSE, format, ptr,
+                                  ctx->Array.VAO))
+      return;
 
    update_array(ctx, VERT_ATTRIB_EDGEFLAG, format, 1, 1, GL_UNSIGNED_BYTE,
                 stride, GL_FALSE, integer, GL_FALSE, ptr);
@@ -803,6 +883,18 @@ _mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr)
 
 
 void GLAPIENTRY
+_mesa_PointSizePointerOES_no_error(GLenum type, GLsizei stride,
+                                   const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+
+   update_array(ctx, VERT_ATTRIB_POINT_SIZE, GL_RGBA, 1, 1, type, stride,
+                GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
 _mesa_PointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *ptr)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -810,27 +902,38 @@ _mesa_PointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *ptr)
    FLUSH_VERTICES(ctx, 0);
 
    GLenum format = GL_RGBA;
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      if (ctx->API != API_OPENGLES) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glPointSizePointer(ES 1.x only)");
-         return;
-      }
+   if (ctx->API != API_OPENGLES) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glPointSizePointer(ES 1.x only)");
+      return;
+   }
 
-      const GLbitfield legalTypes = (FLOAT_BIT | FIXED_ES_BIT);
+   const GLbitfield legalTypes = (FLOAT_BIT | FIXED_ES_BIT);
 
-      if (!validate_array_and_format(ctx, "glPointSizePointer",
-                                     VERT_ATTRIB_POINT_SIZE, legalTypes,
-                                     1, 1, 1, type, stride, GL_FALSE, GL_FALSE,
-                                     GL_FALSE, format, ptr, ctx->Array.VAO))
-         return;
-   }
+   if (!validate_array_and_format(ctx, "glPointSizePointer",
+                                  VERT_ATTRIB_POINT_SIZE, legalTypes,
+                                  1, 1, 1, type, stride, GL_FALSE, GL_FALSE,
+                                  GL_FALSE, format, ptr, ctx->Array.VAO))
+      return;
 
    update_array(ctx, VERT_ATTRIB_POINT_SIZE, format, 1, 1, type, stride,
                 GL_FALSE, GL_FALSE, GL_FALSE, ptr);
 }
 
 
+void GLAPIENTRY
+_mesa_VertexAttribPointer_no_error(GLuint index, GLint size, GLenum type,
+                                   GLboolean normalized,
+                                   GLsizei stride, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+   update_array(ctx, VERT_ATTRIB_GENERIC(index), format, BGRA_OR_4,
+                size, type, stride, normalized, GL_FALSE, GL_FALSE, ptr);
+}
+
+
 /**
  * Set a generic vertex attribute array.
  * Note that these arrays DO NOT alias the conventional GL vertex arrays
@@ -844,34 +947,45 @@ _mesa_VertexAttribPointer(GLuint index, GLint size, GLenum type,
    GET_CURRENT_CONTEXT(ctx);
 
    GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(idx)");
-         return;
-      }
-
-      const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
-                                     SHORT_BIT | UNSIGNED_SHORT_BIT |
-                                     INT_BIT | UNSIGNED_INT_BIT |
-                                     HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
-                                     FIXED_ES_BIT | FIXED_GL_BIT |
-                                     UNSIGNED_INT_2_10_10_10_REV_BIT |
-                                     INT_2_10_10_10_REV_BIT |
-                                     UNSIGNED_INT_10F_11F_11F_REV_BIT);
-
-      if (!validate_array_and_format(ctx, "glVertexAttribPointer",
-                                     VERT_ATTRIB_GENERIC(index), legalTypes,
-                                     1, BGRA_OR_4, size, type, stride,
-                                     normalized, GL_FALSE, GL_FALSE, format,
-                                     ptr, ctx->Array.VAO))
-         return;
+   if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(idx)");
+      return;
    }
 
+   const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
+                                  SHORT_BIT | UNSIGNED_SHORT_BIT |
+                                  INT_BIT | UNSIGNED_INT_BIT |
+                                  HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+                                  FIXED_ES_BIT | FIXED_GL_BIT |
+                                  UNSIGNED_INT_2_10_10_10_REV_BIT |
+                                  INT_2_10_10_10_REV_BIT |
+                                  UNSIGNED_INT_10F_11F_11F_REV_BIT);
+
+   if (!validate_array_and_format(ctx, "glVertexAttribPointer",
+                                  VERT_ATTRIB_GENERIC(index), legalTypes,
+                                  1, BGRA_OR_4, size, type, stride,
+                                  normalized, GL_FALSE, GL_FALSE, format,
+                                  ptr, ctx->Array.VAO))
+      return;
+
    update_array(ctx, VERT_ATTRIB_GENERIC(index), format, BGRA_OR_4,
                 size, type, stride, normalized, GL_FALSE, GL_FALSE, ptr);
 }
 
 
+void GLAPIENTRY
+_mesa_VertexAttribIPointer_no_error(GLuint index, GLint size, GLenum type,
+                                    GLsizei stride, const GLvoid *ptr)
+{
+   const GLboolean normalized = GL_FALSE;
+   const GLboolean integer = GL_TRUE;
+   GET_CURRENT_CONTEXT(ctx);
+
+   update_array(ctx, VERT_ATTRIB_GENERIC(index), GL_RGBA, 4,  size, type,
+                stride, normalized, integer, GL_FALSE, ptr);
+}
+
+
 /**
  * GL_EXT_gpu_shader4 / GL 3.0.
  * Set an integer-valued vertex attribute array.
@@ -887,28 +1001,38 @@ _mesa_VertexAttribIPointer(GLuint index, GLint size, GLenum type,
    GET_CURRENT_CONTEXT(ctx);
 
    GLenum format = GL_RGBA;
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribIPointer(index)");
-         return;
-      }
+   if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribIPointer(index)");
+      return;
+   }
 
-      const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
-                                     SHORT_BIT | UNSIGNED_SHORT_BIT |
-                                     INT_BIT | UNSIGNED_INT_BIT);
+   const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
+                                  SHORT_BIT | UNSIGNED_SHORT_BIT |
+                                  INT_BIT | UNSIGNED_INT_BIT);
 
-      if (!validate_array_and_format(ctx, "glVertexAttribIPointer",
-                                     VERT_ATTRIB_GENERIC(index), legalTypes,
-                                     1, 4, size, type, stride,
-                                     normalized, integer, GL_FALSE, format,
-                                     ptr, ctx->Array.VAO))
-         return;
-   }
+   if (!validate_array_and_format(ctx, "glVertexAttribIPointer",
+                                  VERT_ATTRIB_GENERIC(index), legalTypes,
+                                  1, 4, size, type, stride,
+                                  normalized, integer, GL_FALSE, format,
+                                  ptr, ctx->Array.VAO))
+      return;
 
    update_array(ctx, VERT_ATTRIB_GENERIC(index), format, 4,  size, type,
                 stride, normalized, integer, GL_FALSE, ptr);
 }
 
+
+void GLAPIENTRY
+_mesa_VertexAttribLPointer_no_error(GLuint index, GLint size, GLenum type,
+                                    GLsizei stride, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   update_array(ctx, VERT_ATTRIB_GENERIC(index), GL_RGBA, 4, size, type,
+                stride, GL_FALSE, GL_FALSE, GL_TRUE, ptr);
+}
+
+
 void GLAPIENTRY
 _mesa_VertexAttribLPointer(GLuint index, GLint size, GLenum type,
                            GLsizei stride, const GLvoid *ptr)
@@ -916,21 +1040,19 @@ _mesa_VertexAttribLPointer(GLuint index, GLint size, GLenum type,
    GET_CURRENT_CONTEXT(ctx);
 
    GLenum format = GL_RGBA;
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribLPointer(index)");
-         return;
-      }
+   if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribLPointer(index)");
+      return;
+   }
 
-      const GLbitfield legalTypes = DOUBLE_BIT;
+   const GLbitfield legalTypes = DOUBLE_BIT;
 
-      if (!validate_array_and_format(ctx, "glVertexAttribLPointer",
-                                     VERT_ATTRIB_GENERIC(index), legalTypes,
-                                     1, 4, size, type, stride,
-                                     GL_FALSE, GL_FALSE, GL_TRUE, format,
-                                     ptr, ctx->Array.VAO))
-         return;
-   }
+   if (!validate_array_and_format(ctx, "glVertexAttribLPointer",
+                                  VERT_ATTRIB_GENERIC(index), legalTypes,
+                                  1, 4, size, type, stride,
+                                  GL_FALSE, GL_FALSE, GL_TRUE, format,
+                                  ptr, ctx->Array.VAO))
+      return;
 
    update_array(ctx, VERT_ATTRIB_GENERIC(index), format, 4, size, type,
                 stride, GL_FALSE, GL_FALSE, GL_TRUE, ptr);
@@ -1759,6 +1881,32 @@ _mesa_PrimitiveRestartIndex(GLuint index)
 }
 
 
+void GLAPIENTRY
+_mesa_VertexAttribDivisor_no_error(GLuint index, GLuint divisor)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   const GLuint genericIndex = VERT_ATTRIB_GENERIC(index);
+   struct gl_vertex_array_object * const vao = ctx->Array.VAO;
+
+   assert(genericIndex < ARRAY_SIZE(vao->VertexAttrib));
+
+   /* The ARB_vertex_attrib_binding spec says:
+    *
+    *    "The command
+    *
+    *       void VertexAttribDivisor(uint index, uint divisor);
+    *
+    *     is equivalent to (assuming no errors are generated):
+    *
+    *       VertexAttribBinding(index, index);
+    *       VertexBindingDivisor(index, divisor);"
+    */
+   vertex_attrib_binding(ctx, vao, genericIndex, genericIndex);
+   vertex_binding_divisor(ctx, vao, genericIndex, divisor);
+}
+
+
 /**
  * See GL_ARB_instanced_arrays.
  * Note that the instance divisor only applies to generic arrays, not
@@ -1772,17 +1920,15 @@ _mesa_VertexAttribDivisor(GLuint index, GLuint divisor)
    const GLuint genericIndex = VERT_ATTRIB_GENERIC(index);
    struct gl_vertex_array_object * const vao = ctx->Array.VAO;
 
-   if (!_mesa_is_no_error_enabled(ctx)) {
-      if (!ctx->Extensions.ARB_instanced_arrays) {
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glVertexAttribDivisor()");
-         return;
-      }
+   if (!ctx->Extensions.ARB_instanced_arrays) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glVertexAttribDivisor()");
+      return;
+   }
 
-      if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glVertexAttribDivisor(index = %u)", index);
-         return;
-      }
+   if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glVertexAttribDivisor(index = %u)", index);
+      return;
    }
 
    assert(genericIndex < ARRAY_SIZE(vao->VertexAttrib));