X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fbufferobj.c;h=1f0c683f817426afaf1cf4ea56789f0b7fbc53e1;hb=3ade766684933ac84e41634429fb693f85353c11;hp=fc7dac2652a039be75babb7c3c560cf06986f183;hpb=96ff2edc73ccf11d4d198ba3665507f73ae4a9f7;p=mesa.git

diff --git a/src/mesa/main/bufferobj.c b/src/mesa/main/bufferobj.c
index fc7dac2652a..1f0c683f817 100644
--- a/src/mesa/main/bufferobj.c
+++ b/src/mesa/main/bufferobj.c
@@ -1,6 +1,5 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.6
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
@@ -18,9 +17,10 @@
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
  */
 
 
@@ -41,6 +41,9 @@
 #include "fbobject.h"
 #include "mtypes.h"
 #include "texobj.h"
+#include "teximage.h"
+#include "glformats.h"
+#include "texstore.h"
 #include "transformfeedback.h"
 #include "dispatch.h"
 
@@ -86,6 +89,12 @@ get_buffer_target(struct gl_context *ctx, GLenum target)
       return &ctx->CopyReadBuffer;
    case GL_COPY_WRITE_BUFFER:
       return &ctx->CopyWriteBuffer;
+   case GL_DRAW_INDIRECT_BUFFER:
+      if (ctx->API == API_OPENGL_CORE &&
+          ctx->Extensions.ARB_draw_indirect) {
+         return &ctx->DrawIndirectBuffer;
+      }
+      break;
    case GL_TRANSFORM_FEEDBACK_BUFFER:
       if (ctx->Extensions.EXT_transform_feedback) {
          return &ctx->TransformFeedback.CurrentBuffer;
@@ -102,6 +111,11 @@ get_buffer_target(struct gl_context *ctx, GLenum target)
          return &ctx->UniformBuffer;
       }
       break;
+   case GL_ATOMIC_COUNTER_BUFFER:
+      if (ctx->Extensions.ARB_shader_atomic_counters) {
+         return &ctx->AtomicBuffer;
+      }
+      break;
    default:
       return NULL;
    }
@@ -113,11 +127,13 @@ get_buffer_target(struct gl_context *ctx, GLenum target)
  * Get the buffer object bound to the specified target in a GL context.
  * \param ctx  the GL context
  * \param target  the buffer object target to be retrieved.
+ * \param error  the GL error to record if target is illegal.
  * \return   pointer to the buffer object bound to \c target in the
  *           specified context or \c NULL if \c target is invalid.
  */
 static inline struct gl_buffer_object *
-get_buffer(struct gl_context *ctx, const char *func, GLenum target)
+get_buffer(struct gl_context *ctx, const char *func, GLenum target,
+           GLenum error)
 {
    struct gl_buffer_object **bufObj = get_buffer_target(ctx, target);
 
@@ -127,7 +143,7 @@ get_buffer(struct gl_context *ctx, const char *func, GLenum target)
    }
 
    if (!_mesa_is_bufferobj(*bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "%s(buffer 0)", func);
+      _mesa_error(ctx, error, "%s(no buffer bound)", func);
       return NULL;
    }
 
@@ -174,26 +190,59 @@ simplified_access_mode(struct gl_context *ctx, GLbitfield access)
 }
 
 
+/**
+ * Test if the buffer is mapped, and if so, if the mapped range overlaps the
+ * given range.
+ * The regions do not overlap if and only if the end of the given
+ * region is before the mapped region or the start of the given region
+ * is after the mapped region.
+ *
+ * \param obj     Buffer object target on which to operate.
+ * \param offset  Offset of the first byte of the subdata range.
+ * \param size    Size, in bytes, of the subdata range.
+ * \return   true if ranges overlap, false otherwise
+ *
+ */
+static bool
+bufferobj_range_mapped(const struct gl_buffer_object *obj,
+                       GLintptr offset, GLsizeiptr size)
+{
+   if (_mesa_bufferobj_mapped(obj)) {
+      const GLintptr end = offset + size;
+      const GLintptr mapEnd = obj->Offset + obj->Length;
+
+      if (!(end <= obj->Offset || offset >= mapEnd)) {
+         return true;
+      }
+   }
+   return false;
+}
+
+
 /**
  * Tests the subdata range parameters and sets the GL error code for
- * \c glBufferSubDataARB and \c glGetBufferSubDataARB.
+ * \c glBufferSubDataARB, \c glGetBufferSubDataARB and
+ * \c glClearBufferSubData.
  *
  * \param ctx     GL context.
  * \param target  Buffer object target on which to operate.
  * \param offset  Offset of the first byte of the subdata range.
  * \param size    Size, in bytes, of the subdata range.
+ * \param mappedRange  If true, checks if an overlapping range is mapped.
+ *                     If false, checks if buffer is mapped.
+ * \param errorNoBuffer  Error code if no buffer is bound to target.
  * \param caller  Name of calling function for recording errors.
  * \return   A pointer to the buffer object bound to \c target in the
  *           specified context or \c NULL if any of the parameter or state
- *           conditions for \c glBufferSubDataARB or \c glGetBufferSubDataARB
- *           are invalid.
+ *           conditions are invalid.
  *
- * \sa glBufferSubDataARB, glGetBufferSubDataARB
+ * \sa glBufferSubDataARB, glGetBufferSubDataARB, glClearBufferSubData
  */
 static struct gl_buffer_object *
-buffer_object_subdata_range_good( struct gl_context * ctx, GLenum target, 
-                                  GLintptrARB offset, GLsizeiptrARB size,
-                                  const char *caller )
+buffer_object_subdata_range_good(struct gl_context * ctx, GLenum target,
+                                 GLintptrARB offset, GLsizeiptrARB size,
+                                 bool mappedRange, GLenum errorNoBuffer,
+                                 const char *caller)
 {
    struct gl_buffer_object *bufObj;
 
@@ -207,28 +256,128 @@ buffer_object_subdata_range_good( struct gl_context * ctx, GLenum target,
       return NULL;
    }
 
-   bufObj = get_buffer(ctx, caller, target);
+   bufObj = get_buffer(ctx, caller, target, errorNoBuffer);
    if (!bufObj)
       return NULL;
 
    if (offset + size > bufObj->Size) {
       _mesa_error(ctx, GL_INVALID_VALUE,
-		  "%s(offset %lu + size %lu > buffer size %lu)", caller,
+                  "%s(offset %lu + size %lu > buffer size %lu)", caller,
                   (unsigned long) offset,
                   (unsigned long) size,
                   (unsigned long) bufObj->Size);
       return NULL;
    }
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      /* Buffer is currently mapped */
-      _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
-      return NULL;
+
+   if (mappedRange) {
+      if (bufferobj_range_mapped(bufObj, offset, size)) {
+         _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
+         return NULL;
+      }
+   }
+   else {
+      if (_mesa_bufferobj_mapped(bufObj)) {
+         _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
+         return NULL;
+      }
    }
 
    return bufObj;
 }
 
 
+/**
+ * Test the format and type parameters and set the GL error code for
+ * \c glClearBufferData and \c glClearBufferSubData.
+ *
+ * \param ctx             GL context.
+ * \param internalformat  Format to which the data is to be converted.
+ * \param format          Format of the supplied data.
+ * \param type            Type of the supplied data.
+ * \param caller          Name of calling function for recording errors.
+ * \return   If internalformat, format and type are legal the mesa_format
+ *           corresponding to internalformat, otherwise MESA_FORMAT_NONE.
+ *
+ * \sa glClearBufferData and glClearBufferSubData
+ */
+static mesa_format
+validate_clear_buffer_format(struct gl_context *ctx,
+                             GLenum internalformat,
+                             GLenum format, GLenum type,
+                             const char *caller)
+{
+   mesa_format mesaFormat;
+   GLenum errorFormatType;
+
+   mesaFormat = _mesa_validate_texbuffer_format(ctx, internalformat);
+   if (mesaFormat == MESA_FORMAT_NONE) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "%s(invalid internalformat)", caller);
+      return MESA_FORMAT_NONE;
+   }
+
+   /* NOTE: not mentioned in ARB_clear_buffer_object but according to
+    * EXT_texture_integer there is no conversion between integer and
+    * non-integer formats
+   */
+   if (_mesa_is_enum_format_signed_int(format) !=
+       _mesa_is_format_integer_color(mesaFormat)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "%s(integer vs non-integer)", caller);
+      return MESA_FORMAT_NONE;
+   }
+
+   if (!_mesa_is_color_format(format)) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "%s(format is not a color format)", caller);
+      return MESA_FORMAT_NONE;
+   }
+
+   errorFormatType = _mesa_error_check_format_and_type(ctx, format, type);
+   if (errorFormatType != GL_NO_ERROR) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "%s(invalid format or type)", caller);
+      return MESA_FORMAT_NONE;
+   }
+
+   return mesaFormat;
+}
+
+
+/**
+ * Convert user-specified clear value to the specified internal format.
+ *
+ * \param ctx             GL context.
+ * \param internalformat  Format to which the data is converted.
+ * \param clearValue      Points to the converted clear value.
+ * \param format          Format of the supplied data.
+ * \param type            Type of the supplied data.
+ * \param data            Data which is to be converted to internalformat.
+ * \param caller          Name of calling function for recording errors.
+ * \return   true if data could be converted, false otherwise.
+ *
+ * \sa glClearBufferData, glClearBufferSubData
+ */
+static bool
+convert_clear_buffer_data(struct gl_context *ctx,
+                          mesa_format internalformat,
+                          GLubyte *clearValue, GLenum format, GLenum type,
+                          const GLvoid *data, const char *caller)
+{
+   GLenum internalformatBase = _mesa_get_format_base_format(internalformat);
+
+   if (_mesa_texstore(ctx, 1, internalformatBase, internalformat,
+                      0, &clearValue, 1, 1, 1,
+                      format, type, data, &ctx->Unpack)) {
+      return true;
+   }
+   else {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", caller);
+      return false;
+   }
+}
+
+
 /**
  * Allocate and initialize a new buffer object.
  * 
@@ -258,13 +407,14 @@ _mesa_delete_buffer_object(struct gl_context *ctx,
 {
    (void) ctx;
 
-   free(bufObj->Data);
+   _mesa_align_free(bufObj->Data);
 
    /* assign strange values here to help w/ debugging */
    bufObj->RefCount = -1000;
    bufObj->Name = ~0;
 
    _glthread_DESTROY_MUTEX(bufObj->Mutex);
+   free(bufObj->Label);
    free(bufObj);
 }
 
@@ -410,9 +560,12 @@ _mesa_buffer_data( struct gl_context *ctx, GLenum target, GLsizeiptrARB size,
 {
    void * new_data;
 
-   (void) ctx; (void) target;
+   (void) target;
+
+   if (bufObj->Data)
+      _mesa_align_free( bufObj->Data );
 
-   new_data = _mesa_realloc( bufObj->Data, bufObj->Size, size );
+   new_data = _mesa_align_malloc( size, ctx->Const.MinMapBufferAlignment );
    if (new_data) {
       bufObj->Data = (GLubyte *) new_data;
       bufObj->Size = size;
@@ -439,7 +592,6 @@ _mesa_buffer_data( struct gl_context *ctx, GLenum target, GLsizeiptrARB size,
  * Note that all GL error checking will have been done already.
  *
  * \param ctx     GL context.
- * \param target  Buffer object target on which to operate.
  * \param offset  Offset of the first byte to be modified.
  * \param size    Size, in bytes, of the data range.
  * \param data    Pointer to the data to store in the buffer object.
@@ -493,6 +645,82 @@ _mesa_buffer_get_subdata( struct gl_context *ctx, GLintptrARB offset,
 }
 
 
+/**
+ * Clear a subrange of the buffer object with copies of the supplied data.
+ * If data is NULL the buffer is filled with zeros.
+ *
+ * This is the default callback for \c dd_function_table::ClearBufferSubData()
+ * Note that all GL error checking will have been done already.
+ *
+ * \param ctx             GL context.
+ * \param offset          Offset of the first byte to be cleared.
+ * \param size            Size, in bytes, of the to be cleared range.
+ * \param clearValue      Source of the data.
+ * \param clearValueSize  Size, in bytes, of the supplied data.
+ * \param bufObj          Object to be cleared.
+ *
+ * \sa glClearBufferSubData, glClearBufferData and
+ * dd_function_table::ClearBufferSubData.
+ */
+static void
+_mesa_buffer_clear_subdata(struct gl_context *ctx,
+                           GLintptr offset, GLsizeiptr size,
+                           const GLvoid *clearValue,
+                           GLsizeiptr clearValueSize,
+                           struct gl_buffer_object *bufObj)
+{
+   GLsizeiptr i;
+   GLubyte *dest;
+
+   if (_mesa_bufferobj_mapped(bufObj)) {
+      GLubyte *data = malloc(size);
+      GLubyte *dataStart = data;
+      if (data == NULL) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClearBuffer[Sub]Data");
+         return;
+      }
+
+      if (clearValue == NULL) {
+         /* Clear with zeros, per the spec */
+         memset(data, 0, size);
+      }
+      else {
+         for (i = 0; i < size/clearValueSize; ++i) {
+            memcpy(data, clearValue, clearValueSize);
+            data += clearValueSize;
+         }
+      }
+      ctx->Driver.BufferSubData(ctx, offset, size, dataStart, bufObj);
+      return;
+   }
+
+   ASSERT(ctx->Driver.MapBufferRange);
+   dest = ctx->Driver.MapBufferRange(ctx, offset, size,
+                                     GL_MAP_WRITE_BIT |
+                                     GL_MAP_INVALIDATE_RANGE_BIT,
+                                     bufObj);
+
+   if (!dest) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClearBuffer[Sub]Data");
+      return;
+   }
+
+   if (clearValue == NULL) {
+      /* Clear with zeros, per the spec */
+      memset(dest, 0, size);
+      ctx->Driver.UnmapBuffer(ctx, bufObj);
+      return;
+   }
+
+   for (i = 0; i < size/clearValueSize; ++i) {
+      memcpy(dest, clearValue, clearValueSize);
+      dest += clearValueSize;
+   }
+
+   ctx->Driver.UnmapBuffer(ctx, bufObj);
+}
+
+
 /**
  * Default fallback for \c dd_function_table::MapBufferRange().
  * Called via glMapBufferRange().
@@ -618,13 +846,13 @@ _mesa_init_buffer_objects( struct gl_context *ctx )
    _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer,
                                  ctx->Shared->NullBufferObj);
 
-   ctx->UniformBufferBindings = calloc(ctx->Const.MaxUniformBufferBindings,
-				      sizeof(*ctx->UniformBufferBindings));
-
    _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer,
 				 ctx->Shared->NullBufferObj);
 
-   for (i = 0; i < ctx->Const.MaxUniformBufferBindings; i++) {
+   _mesa_reference_buffer_object(ctx, &ctx->DrawIndirectBuffer,
+				 ctx->Shared->NullBufferObj);
+
+   for (i = 0; i < MAX_COMBINED_UNIFORM_BUFFERS; i++) {
       _mesa_reference_buffer_object(ctx,
 				    &ctx->UniformBufferBindings[i].BufferObject,
 				    ctx->Shared->NullBufferObj);
@@ -646,26 +874,26 @@ _mesa_free_buffer_objects( struct gl_context *ctx )
 
    _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer, NULL);
 
-   for (i = 0; i < ctx->Const.MaxUniformBufferBindings; i++) {
+   _mesa_reference_buffer_object(ctx, &ctx->DrawIndirectBuffer, NULL);
+
+   for (i = 0; i < MAX_COMBINED_UNIFORM_BUFFERS; i++) {
       _mesa_reference_buffer_object(ctx,
 				    &ctx->UniformBufferBindings[i].BufferObject,
 				    NULL);
    }
-
-   free(ctx->UniformBufferBindings);
-   ctx->UniformBufferBindings = NULL;
 }
 
-static bool
-handle_bind_buffer_gen(struct gl_context *ctx,
-		       GLenum target,
-		       GLuint buffer,
-		       struct gl_buffer_object **buf_handle)
+bool
+_mesa_handle_bind_buffer_gen(struct gl_context *ctx,
+                             GLenum target,
+                             GLuint buffer,
+                             struct gl_buffer_object **buf_handle,
+                             const char *caller)
 {
    struct gl_buffer_object *buf = *buf_handle;
 
    if (!buf && ctx->API == API_OPENGL_CORE) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glBindBuffer(non-gen name)");
+      _mesa_error(ctx, GL_INVALID_OPERATION, "%s(non-gen name)", caller);
       return false;
    }
 
@@ -676,7 +904,7 @@ handle_bind_buffer_gen(struct gl_context *ctx,
       ASSERT(ctx->Driver.NewBufferObject);
       buf = ctx->Driver.NewBufferObject(ctx, buffer, target);
       if (!buf) {
-	 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindBufferARB");
+	 _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", caller);
 	 return false;
       }
       _mesa_HashInsert(ctx->Shared->BufferObjects, buffer, buf);
@@ -720,7 +948,8 @@ bind_buffer_object(struct gl_context *ctx, GLenum target, GLuint buffer)
    else {
       /* non-default buffer object */
       newBufObj = _mesa_lookup_bufferobj(ctx, buffer);
-      if (!handle_bind_buffer_gen(ctx, target, buffer, &newBufObj))
+      if (!_mesa_handle_bind_buffer_gen(ctx, target, buffer,
+                                        &newBufObj, "glBindBuffer"))
          return;
    }
    
@@ -800,6 +1029,9 @@ _mesa_init_buffer_object_functions(struct dd_function_table *driver)
    driver->GetBufferSubData = _mesa_buffer_get_subdata;
    driver->UnmapBuffer = _mesa_buffer_unmap;
 
+   /* GL_ARB_clear_buffer_object */
+   driver->ClearBufferSubData = _mesa_buffer_clear_subdata;
+
    /* GL_ARB_map_buffer_range */
    driver->MapBufferRange = _mesa_buffer_map_range;
    driver->FlushMappedBufferRange = _mesa_buffer_flush_mapped_range;
@@ -863,8 +1095,8 @@ _mesa_DeleteBuffers(GLsizei n, const GLuint *ids)
          }
 
          /* unbind any vertex pointers bound to this buffer */
-         for (j = 0; j < Elements(arrayObj->VertexAttrib); j++) {
-            unbind(ctx, &arrayObj->VertexAttrib[j].BufferObj, bufObj);
+         for (j = 0; j < Elements(arrayObj->VertexBinding); j++) {
+            unbind(ctx, &arrayObj->VertexBinding[j].BufferObj, bufObj);
          }
 
          if (ctx->Array.ArrayBufferObj == bufObj) {
@@ -874,6 +1106,11 @@ _mesa_DeleteBuffers(GLsizei n, const GLuint *ids)
             _mesa_BindBuffer( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );
          }
 
+         /* unbind ARB_draw_indirect binding point */
+         if (ctx->DrawIndirectBuffer == bufObj) {
+            _mesa_BindBuffer( GL_DRAW_INDIRECT_BUFFER, 0 );
+         }
+
          /* unbind ARB_copy_buffer binding points */
          if (ctx->CopyReadBuffer == bufObj) {
             _mesa_BindBuffer( GL_COPY_READ_BUFFER, 0 );
@@ -1049,7 +1286,7 @@ _mesa_BufferData(GLenum target, GLsizeiptrARB size,
       return;
    }
 
-   bufObj = get_buffer(ctx, "glBufferDataARB", target);
+   bufObj = get_buffer(ctx, "glBufferDataARB", target, GL_INVALID_OPERATION);
    if (!bufObj)
       return;
 
@@ -1088,6 +1325,7 @@ _mesa_BufferSubData(GLenum target, GLintptrARB offset,
    struct gl_buffer_object *bufObj;
 
    bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,
+                                              false, GL_INVALID_OPERATION,
                                               "glBufferSubDataARB" );
    if (!bufObj) {
       /* error already recorded */
@@ -1111,8 +1349,9 @@ _mesa_GetBufferSubData(GLenum target, GLintptrARB offset,
    GET_CURRENT_CONTEXT(ctx);
    struct gl_buffer_object *bufObj;
 
-   bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,
-                                              "glGetBufferSubDataARB" );
+   bufObj = buffer_object_subdata_range_good(ctx, target, offset, size,
+                                             false, GL_INVALID_OPERATION,
+                                             "glGetBufferSubDataARB");
    if (!bufObj) {
       /* error already recorded */
       return;
@@ -1123,6 +1362,111 @@ _mesa_GetBufferSubData(GLenum target, GLintptrARB offset,
 }
 
 
+void GLAPIENTRY
+_mesa_ClearBufferData(GLenum target, GLenum internalformat, GLenum format,
+                      GLenum type, const GLvoid* data)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object* bufObj;
+   mesa_format mesaFormat;
+   GLubyte clearValue[MAX_PIXEL_BYTES];
+   GLsizeiptr clearValueSize;
+
+   bufObj = get_buffer(ctx, "glClearBufferData", target, GL_INVALID_VALUE);
+   if (!bufObj) {
+      return;
+   }
+
+   if (_mesa_bufferobj_mapped(bufObj)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glClearBufferData(buffer currently mapped)");
+      return;
+   }
+
+   mesaFormat = validate_clear_buffer_format(ctx, internalformat,
+                                             format, type,
+                                             "glClearBufferData");
+   if (mesaFormat == MESA_FORMAT_NONE) {
+      return;
+   }
+
+   clearValueSize = _mesa_get_format_bytes(mesaFormat);
+   if (bufObj->Size % clearValueSize != 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glClearBufferData(size is not a multiple of "
+                  "internalformat size)");
+      return;
+   }
+
+   if (data == NULL) {
+      /* clear to zeros, per the spec */
+      ctx->Driver.ClearBufferSubData(ctx, 0, bufObj->Size,
+                                     NULL, 0, bufObj);
+      return;
+   }
+
+   if (!convert_clear_buffer_data(ctx, mesaFormat, clearValue,
+                                  format, type, data, "glClearBufferData")) {
+      return;
+   }
+
+   ctx->Driver.ClearBufferSubData(ctx, 0, bufObj->Size,
+                                  clearValue, clearValueSize, bufObj);
+}
+
+
+void GLAPIENTRY
+_mesa_ClearBufferSubData(GLenum target, GLenum internalformat,
+                         GLintptr offset, GLsizeiptr size,
+                         GLenum format, GLenum type,
+                         const GLvoid* data)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object* bufObj;
+   mesa_format mesaFormat;
+   GLubyte clearValue[MAX_PIXEL_BYTES];
+   GLsizeiptr clearValueSize;
+
+   bufObj = buffer_object_subdata_range_good(ctx, target, offset, size,
+                                             true, GL_INVALID_VALUE,
+                                             "glClearBufferSubData");
+   if (!bufObj) {
+      return;
+   }
+
+   mesaFormat = validate_clear_buffer_format(ctx, internalformat,
+                                             format, type,
+                                             "glClearBufferSubData");
+   if (mesaFormat == MESA_FORMAT_NONE) {
+      return;
+   }
+
+   clearValueSize = _mesa_get_format_bytes(mesaFormat);
+   if (offset % clearValueSize != 0 || size % clearValueSize != 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glClearBufferSubData(offset or size is not a multiple of "
+                  "internalformat size)");
+      return;
+   }
+
+   if (data == NULL) {
+      /* clear to zeros, per the spec */
+      ctx->Driver.ClearBufferSubData(ctx, offset, size,
+                                     NULL, 0, bufObj);
+      return;
+   }
+
+   if (!convert_clear_buffer_data(ctx, mesaFormat, clearValue,
+                                  format, type, data,
+                                  "glClearBufferSubData")) {
+      return;
+   }
+
+   ctx->Driver.ClearBufferSubData(ctx, offset, size,
+                                  clearValue, clearValueSize, bufObj);
+}
+
+
 void * GLAPIENTRY
 _mesa_MapBuffer(GLenum target, GLenum access)
 {
@@ -1157,7 +1501,7 @@ _mesa_MapBuffer(GLenum target, GLenum access)
       return NULL;
    }
 
-   bufObj = get_buffer(ctx, "glMapBufferARB", target);
+   bufObj = get_buffer(ctx, "glMapBufferARB", target, GL_INVALID_OPERATION);
    if (!bufObj)
       return NULL;
 
@@ -1226,7 +1570,7 @@ _mesa_UnmapBuffer(GLenum target)
    GLboolean status = GL_TRUE;
    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 
-   bufObj = get_buffer(ctx, "glUnmapBufferARB", target);
+   bufObj = get_buffer(ctx, "glUnmapBufferARB", target, GL_INVALID_OPERATION);
    if (!bufObj)
       return GL_FALSE;
 
@@ -1287,7 +1631,8 @@ _mesa_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
    GET_CURRENT_CONTEXT(ctx);
    struct gl_buffer_object *bufObj;
 
-   bufObj = get_buffer(ctx, "glGetBufferParameterivARB", target);
+   bufObj = get_buffer(ctx, "glGetBufferParameterivARB", target,
+                       GL_INVALID_OPERATION);
    if (!bufObj)
       return;
 
@@ -1340,7 +1685,8 @@ _mesa_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
    GET_CURRENT_CONTEXT(ctx);
    struct gl_buffer_object *bufObj;
 
-   bufObj = get_buffer(ctx, "glGetBufferParameteri64v", target);
+   bufObj = get_buffer(ctx, "glGetBufferParameteri64v", target,
+                       GL_INVALID_OPERATION);
    if (!bufObj)
       return;
 
@@ -1393,7 +1739,8 @@ _mesa_GetBufferPointerv(GLenum target, GLenum pname, GLvoid **params)
       return;
    }
 
-   bufObj = get_buffer(ctx, "glGetBufferPointervARB", target);
+   bufObj = get_buffer(ctx, "glGetBufferPointervARB", target,
+                       GL_INVALID_OPERATION);
    if (!bufObj)
       return;
 
@@ -1409,11 +1756,13 @@ _mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
    GET_CURRENT_CONTEXT(ctx);
    struct gl_buffer_object *src, *dst;
 
-   src = get_buffer(ctx, "glCopyBufferSubData", readTarget);
+   src = get_buffer(ctx, "glCopyBufferSubData", readTarget,
+                    GL_INVALID_OPERATION);
    if (!src)
       return;
 
-   dst = get_buffer(ctx, "glCopyBufferSubData", writeTarget);
+   dst = get_buffer(ctx, "glCopyBufferSubData", writeTarget,
+                    GL_INVALID_OPERATION);
    if (!dst)
       return;
 
@@ -1557,7 +1906,7 @@ _mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
       return NULL;
    }
 
-   bufObj = get_buffer(ctx, "glMapBufferRange", target);
+   bufObj = get_buffer(ctx, "glMapBufferRange", target, GL_INVALID_OPERATION);
    if (!bufObj)
       return NULL;
 
@@ -1636,7 +1985,8 @@ _mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
       return;
    }
 
-   bufObj = get_buffer(ctx, "glFlushMappedBufferRange", target);
+   bufObj = get_buffer(ctx, "glFlushMappedBufferRange", target,
+                       GL_INVALID_OPERATION);
    if (!bufObj)
       return;
 
@@ -2059,7 +2409,8 @@ set_ubo_binding(struct gl_context *ctx,
       return;
    }
 
-   FLUSH_VERTICES(ctx, _NEW_BUFFER_OBJECT);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->NewDriverState |= ctx->DriverFlags.NewUniformBuffer;
 
    _mesa_reference_buffer_object(ctx, &binding->BufferObject, bufObj);
    binding->Offset = offset;
@@ -2124,6 +2475,51 @@ bind_buffer_base_uniform_buffer(struct gl_context *ctx,
       set_ubo_binding(ctx, index, bufObj, 0, 0, GL_TRUE);
 }
 
+static void
+set_atomic_buffer_binding(struct gl_context *ctx,
+                          unsigned index,
+                          struct gl_buffer_object *bufObj,
+                          GLintptr offset,
+                          GLsizeiptr size,
+                          const char *name)
+{
+   struct gl_atomic_buffer_binding *binding;
+
+   if (index >= ctx->Const.MaxAtomicBufferBindings) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%d)", name, index);
+      return;
+   }
+
+   if (offset & (ATOMIC_COUNTER_SIZE - 1)) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "%s(offset misalgned %d/%d)", name, (int) offset,
+                  ATOMIC_COUNTER_SIZE);
+      return;
+   }
+
+   _mesa_reference_buffer_object(ctx, &ctx->AtomicBuffer, bufObj);
+
+   binding = &ctx->AtomicBufferBindings[index];
+   if (binding->BufferObject == bufObj &&
+       binding->Offset == offset &&
+       binding->Size == size) {
+      return;
+   }
+
+   FLUSH_VERTICES(ctx, 0);
+   ctx->NewDriverState |= ctx->DriverFlags.NewAtomicBuffer;
+
+   _mesa_reference_buffer_object(ctx, &binding->BufferObject, bufObj);
+
+   if (bufObj == ctx->Shared->NullBufferObj) {
+      binding->Offset = -1;
+      binding->Size = -1;
+   } else {
+      binding->Offset = offset;
+      binding->Size = size;
+   }
+}
+
 void GLAPIENTRY
 _mesa_BindBufferRange(GLenum target, GLuint index,
                       GLuint buffer, GLintptr offset, GLsizeiptr size)
@@ -2136,7 +2532,8 @@ _mesa_BindBufferRange(GLenum target, GLuint index,
    } else {
       bufObj = _mesa_lookup_bufferobj(ctx, buffer);
    }
-   if (!handle_bind_buffer_gen(ctx, target, buffer, &bufObj))
+   if (!_mesa_handle_bind_buffer_gen(ctx, target, buffer,
+                                     &bufObj, "glBindBufferRange"))
       return;
 
    if (!bufObj) {
@@ -2161,6 +2558,10 @@ _mesa_BindBufferRange(GLenum target, GLuint index,
    case GL_UNIFORM_BUFFER:
       bind_buffer_range_uniform_buffer(ctx, index, bufObj, offset, size);
       return;
+   case GL_ATOMIC_COUNTER_BUFFER:
+      set_atomic_buffer_binding(ctx, index, bufObj, offset, size,
+                                "glBindBufferRange");
+      return;
    default:
       _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferRange(target)");
       return;
@@ -2178,7 +2579,8 @@ _mesa_BindBufferBase(GLenum target, GLuint index, GLuint buffer)
    } else {
       bufObj = _mesa_lookup_bufferobj(ctx, buffer);
    }
-   if (!handle_bind_buffer_gen(ctx, target, buffer, &bufObj))
+   if (!_mesa_handle_bind_buffer_gen(ctx, target, buffer,
+                                     &bufObj, "glBindBufferBase"))
       return;
 
    if (!bufObj) {
@@ -2220,6 +2622,10 @@ _mesa_BindBufferBase(GLenum target, GLuint index, GLuint buffer)
    case GL_UNIFORM_BUFFER:
       bind_buffer_base_uniform_buffer(ctx, index, bufObj);
       return;
+   case GL_ATOMIC_COUNTER_BUFFER:
+      set_atomic_buffer_binding(ctx, index, bufObj, 0, 0,
+                                "glBindBufferBase");
+      return;
    default:
       _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferBase(target)");
       return;
@@ -2260,23 +2666,11 @@ _mesa_InvalidateBufferSubData(GLuint buffer, GLintptr offset,
     *     mapped by MapBuffer, or if the invalidate range intersects the range
     *     currently mapped by MapBufferRange."
     */
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      const GLintptr mapEnd = bufObj->Offset + bufObj->Length;
-
-      /* The regions do not overlap if and only if the end of the discard
-       * region is before the mapped region or the start of the discard region
-       * is after the mapped region.
-       *
-       * Note that 'end' and 'mapEnd' are the first byte *after* the discard
-       * region and the mapped region, repsectively.  It is okay for that byte
-       * to be mapped (for 'end') or discarded (for 'mapEnd').
-       */
-      if (!(end <= bufObj->Offset || offset >= mapEnd)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glInvalidateBufferSubData(intersection with mapped "
-                     "range)");
-         return;
-      }
+   if (bufferobj_range_mapped(bufObj, offset, length)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glInvalidateBufferSubData(intersection with mapped "
+                  "range)");
+      return;
    }
 
    /* We don't actually do anything for this yet.  Just return after