X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Ferrors.c;h=aa0ff50ac3742df9e80ceadf3664c51150d09b14;hb=637b6c24785d202e0f608c8dec098d63d857ae0e;hp=405ee824829b34bcfbaa6af1f05b433b00afa27d;hpb=d9249935db113e1244510de0165dc96a0766bba9;p=mesa.git

diff --git a/src/mesa/main/errors.c b/src/mesa/main/errors.c
index 405ee824829..aa0ff50ac37 100644
--- a/src/mesa/main/errors.c
+++ b/src/mesa/main/errors.c
@@ -5,7 +5,6 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  7.1
  *
  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  *
@@ -22,9 +21,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
- * BRIAN PAUL 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.
  */
 
 
@@ -37,15 +37,67 @@
 #include "mtypes.h"
 #include "version.h"
 #include "hash_table.h"
-#include "glapi/glthread.h"
 
-_glthread_DECLARE_STATIC_MUTEX(DynamicIDMutex);
+static mtx_t DynamicIDMutex = _MTX_INITIALIZER_NP;
 static GLuint NextDynamicID = 1;
 
-struct gl_debug_severity
+/**
+ * A namespace element.
+ */
+struct gl_debug_element
 {
    struct simple_node link;
+
    GLuint ID;
+   /* at which severity levels (mesa_debug_severity) is the message enabled */
+   GLbitfield State;
+};
+
+struct gl_debug_namespace
+{
+   struct simple_node Elements;
+   GLbitfield DefaultState;
+};
+
+struct gl_debug_group {
+   struct gl_debug_namespace Namespaces[MESA_DEBUG_SOURCE_COUNT][MESA_DEBUG_TYPE_COUNT];
+};
+
+/**
+ * An error, warning, or other piece of debug information for an application
+ * to consume via GL_ARB_debug_output/GL_KHR_debug.
+ */
+struct gl_debug_message
+{
+   enum mesa_debug_source source;
+   enum mesa_debug_type type;
+   GLuint id;
+   enum mesa_debug_severity severity;
+   GLsizei length;
+   GLcharARB *message;
+};
+
+/**
+ * Debug message log.  It works like a ring buffer.
+ */
+struct gl_debug_log {
+   struct gl_debug_message Messages[MAX_DEBUG_LOGGED_MESSAGES];
+   GLint NextMessage;
+   GLint NumMessages;
+};
+
+struct gl_debug_state
+{
+   GLDEBUGPROC Callback;
+   const void *CallbackData;
+   GLboolean SyncOutput;
+   GLboolean DebugOutput;
+
+   struct gl_debug_group *Groups[MAX_DEBUG_GROUP_STACK_DEPTH];
+   struct gl_debug_message GroupMessages[MAX_DEBUG_GROUP_STACK_DEPTH];
+   GLint GroupStackDepth;
+
+   struct gl_debug_log Log;
 };
 
 static char out_of_memory[] = "Debugging error: out of memory";
@@ -66,14 +118,19 @@ static const GLenum debug_type_enums[] = {
    GL_DEBUG_TYPE_PORTABILITY,
    GL_DEBUG_TYPE_PERFORMANCE,
    GL_DEBUG_TYPE_OTHER,
+   GL_DEBUG_TYPE_MARKER,
+   GL_DEBUG_TYPE_PUSH_GROUP,
+   GL_DEBUG_TYPE_POP_GROUP,
 };
 
 static const GLenum debug_severity_enums[] = {
    GL_DEBUG_SEVERITY_LOW,
    GL_DEBUG_SEVERITY_MEDIUM,
    GL_DEBUG_SEVERITY_HIGH,
+   GL_DEBUG_SEVERITY_NOTIFICATION,
 };
 
+
 static enum mesa_debug_source
 gl_enum_to_debug_source(GLenum e)
 {
@@ -110,6 +167,7 @@ gl_enum_to_debug_severity(GLenum e)
    return i;
 }
 
+
 /**
  * Handles generating a GL_ARB_debug_output message ID generated by the GL or
  * GLSL compiler.
@@ -127,139 +185,405 @@ static void
 debug_get_id(GLuint *id)
 {
    if (!(*id)) {
-      _glthread_LOCK_MUTEX(DynamicIDMutex);
+      mtx_lock(&DynamicIDMutex);
       if (!(*id))
          *id = NextDynamicID++;
-      _glthread_UNLOCK_MUTEX(DynamicIDMutex);
+      mtx_unlock(&DynamicIDMutex);
    }
 }
 
-/*
- * We store a bitfield in the hash table, with five possible values total.
- *
- * The ENABLED_BIT's purpose is self-explanatory.
- *
- * The FOUND_BIT is needed to differentiate the value of DISABLED from
- * the value returned by HashTableLookup() when it can't find the given key.
- *
- * The KNOWN_SEVERITY bit is a bit complicated:
- *
- * A client may call Control() with an array of IDs, then call Control()
- * on all message IDs of a certain severity, then Insert() one of the
- * previously specified IDs, giving us a known severity level, then call
- * Control() on all message IDs of a certain severity level again.
- *
- * After the first call, those IDs will have a FOUND_BIT, but will not
- * exist in any severity-specific list, so the second call will not
- * impact them. This is undesirable but unavoidable given the API:
- * The only entrypoint that gives a severity for a client-defined ID
- * is the Insert() call.
- *
- * For the sake of Control(), we want to maintain the invariant
- * that an ID will either appear in none of the three severity lists,
- * or appear once, to minimize pointless duplication and potential surprises.
- *
- * Because Insert() is the only place that will learn an ID's severity,
- * it should insert an ID into the appropriate list, but only if the ID
- * doesn't exist in it or any other list yet. Because searching all three
- * lists at O(n) is needlessly expensive, we store KNOWN_SEVERITY.
+static void
+debug_message_clear(struct gl_debug_message *msg)
+{
+   if (msg->message != (char*)out_of_memory)
+      free(msg->message);
+   msg->message = NULL;
+   msg->length = 0;
+}
+
+static void
+debug_message_store(struct gl_debug_message *msg,
+                    enum mesa_debug_source source,
+                    enum mesa_debug_type type, GLuint id,
+                    enum mesa_debug_severity severity,
+                    GLsizei len, const char *buf)
+{
+   assert(!msg->message && !msg->length);
+
+   msg->message = malloc(len+1);
+   if (msg->message) {
+      (void) strncpy(msg->message, buf, (size_t)len);
+      msg->message[len] = '\0';
+
+      msg->length = len+1;
+      msg->source = source;
+      msg->type = type;
+      msg->id = id;
+      msg->severity = severity;
+   } else {
+      static GLuint oom_msg_id = 0;
+      debug_get_id(&oom_msg_id);
+
+      /* malloc failed! */
+      msg->message = out_of_memory;
+      msg->length = strlen(out_of_memory)+1;
+      msg->source = MESA_DEBUG_SOURCE_OTHER;
+      msg->type = MESA_DEBUG_TYPE_ERROR;
+      msg->id = oom_msg_id;
+      msg->severity = MESA_DEBUG_SEVERITY_HIGH;
+   }
+}
+
+static void
+debug_namespace_init(struct gl_debug_namespace *ns)
+{
+   make_empty_list(&ns->Elements);
+
+   /* Enable all the messages with severity HIGH or MEDIUM by default */
+   ns->DefaultState = (1 << MESA_DEBUG_SEVERITY_HIGH) |
+                      (1 << MESA_DEBUG_SEVERITY_MEDIUM);
+}
+
+static void
+debug_namespace_clear(struct gl_debug_namespace *ns)
+{
+   struct simple_node *node, *tmp;
+
+   foreach_s(node, tmp, &ns->Elements)
+      free(node);
+}
+
+static bool
+debug_namespace_copy(struct gl_debug_namespace *dst,
+                     const struct gl_debug_namespace *src)
+{
+   struct simple_node *node;
+
+   dst->DefaultState = src->DefaultState;
+
+   make_empty_list(&dst->Elements);
+   foreach(node, &src->Elements) {
+      const struct gl_debug_element *elem =
+         (const struct gl_debug_element *) node;
+      struct gl_debug_element *copy;
+
+      copy = malloc(sizeof(*copy));
+      if (!copy) {
+         debug_namespace_clear(dst);
+         return false;
+      }
+
+      copy->ID = elem->ID;
+      copy->State = elem->State;
+      insert_at_tail(&dst->Elements, &copy->link);
+   }
+
+   return true;
+}
+
+/**
+ * Set the state of \p id in the namespace.
  */
-enum {
-   FOUND_BIT = 1 << 0,
-   ENABLED_BIT = 1 << 1,
-   KNOWN_SEVERITY = 1 << 2,
-
-   /* HashTable reserves zero as a return value meaning 'not found' */
-   NOT_FOUND = 0,
-   DISABLED = FOUND_BIT,
-   ENABLED = ENABLED_BIT | FOUND_BIT
-};
+static bool
+debug_namespace_set(struct gl_debug_namespace *ns,
+                    GLuint id, bool enabled)
+{
+   const uint32_t state = (enabled) ?
+      ((1 << MESA_DEBUG_SEVERITY_COUNT) - 1) : 0;
+   struct gl_debug_element *elem = NULL;
+   struct simple_node *node;
+
+   /* find the element */
+   foreach(node, &ns->Elements) {
+      struct gl_debug_element *tmp = (struct gl_debug_element *) node;
+      if (tmp->ID == id) {
+         elem = tmp;
+         break;
+      }
+   }
+
+   /* we do not need the element if it has the default state */
+   if (ns->DefaultState == state) {
+      if (elem) {
+         remove_from_list(&elem->link);
+         free(elem);
+      }
+      return true;
+   }
+
+   if (!elem) {
+      elem = malloc(sizeof(*elem));
+      if (!elem)
+         return false;
+
+      elem->ID = id;
+      insert_at_tail(&ns->Elements, &elem->link);
+   }
+
+   elem->State = state;
+
+   return true;
+}
 
 /**
- * Returns the state of the given message source/type/ID tuple.
+ * Set the default state of the namespace for \p severity.  When \p severity
+ * is MESA_DEBUG_SEVERITY_COUNT, the default values for all severities are
+ * updated.
  */
-static GLboolean
-should_log(struct gl_context *ctx,
-           enum mesa_debug_source source,
-           enum mesa_debug_type type,
-           GLuint id,
-           enum mesa_debug_severity severity)
+static void
+debug_namespace_set_all(struct gl_debug_namespace *ns,
+                        enum mesa_debug_severity severity,
+                        bool enabled)
 {
-   struct gl_debug_namespace *nspace =
-         &ctx->Debug.Namespaces[source][type];
-   uintptr_t state;
-
-   /* In addition to not being able to store zero as a value, HashTable also
-      can't use zero as a key. */
-   if (id)
-      state = (uintptr_t)_mesa_HashLookup(nspace->IDs, id);
-   else
-      state = nspace->ZeroID;
-
-   /* Only do this once for each ID. This makes sure the ID exists in,
-      at most, one list, and does not pointlessly appear multiple times. */
-   if (!(state & KNOWN_SEVERITY)) {
-      struct gl_debug_severity *entry;
-
-      if (state == NOT_FOUND) {
-         if (ctx->Debug.Defaults[severity][source][type])
-            state = ENABLED;
-         else
-            state = DISABLED;
+   struct simple_node *node, *tmp;
+   uint32_t mask, val;
+
+   /* set all elements to the same state */
+   if (severity == MESA_DEBUG_SEVERITY_COUNT) {
+      ns->DefaultState = (enabled) ? ((1 << severity) - 1) : 0;
+      debug_namespace_clear(ns);
+      make_empty_list(&ns->Elements);
+      return;
+   }
+
+   mask = 1 << severity;
+   val = (enabled) ? mask : 0;
+
+   ns->DefaultState = (ns->DefaultState & ~mask) | val;
+
+   foreach_s(node, tmp, &ns->Elements) {
+      struct gl_debug_element *elem = (struct gl_debug_element *) node;
+
+      elem->State = (elem->State & ~mask) | val;
+      if (elem->State == ns->DefaultState) {
+         remove_from_list(node);
+         free(node);
       }
+   }
+}
 
-      entry = malloc(sizeof *entry);
-      if (!entry)
-         goto out;
+/**
+ * Get the state of \p id in the namespace.
+ */
+static bool
+debug_namespace_get(const struct gl_debug_namespace *ns, GLuint id,
+                    enum mesa_debug_severity severity)
+{
+   struct simple_node *node;
+   uint32_t state;
 
-      state |= KNOWN_SEVERITY;
+   state = ns->DefaultState;
+   foreach(node, &ns->Elements) {
+      struct gl_debug_element *elem = (struct gl_debug_element *) node;
 
-      if (id)
-         _mesa_HashInsert(nspace->IDs, id, (void*)state);
-      else
-         nspace->ZeroID = state;
+      if (elem->ID == id) {
+         state = elem->State;
+         break;
+      }
+   }
 
-      entry->ID = id;
-      insert_at_tail(&nspace->Severity[severity], &entry->link);
+   return (state & (1 << severity));
+}
+
+/**
+ * Allocate and initialize context debug state.
+ */
+static struct gl_debug_state *
+debug_create(void)
+{
+   struct gl_debug_state *debug;
+   int s, t;
+
+   debug = CALLOC_STRUCT(gl_debug_state);
+   if (!debug)
+      return NULL;
+
+   debug->Groups[0] = malloc(sizeof(*debug->Groups[0]));
+   if (!debug->Groups[0]) {
+      free(debug);
+      return NULL;
+   }
+
+   /* Initialize state for filtering known debug messages. */
+   for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) {
+      for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++)
+         debug_namespace_init(&debug->Groups[0]->Namespaces[s][t]);
+   }
+
+   return debug;
+}
+
+/**
+ * Return true if the top debug group points to the group below it.
+ */
+static bool
+debug_is_group_read_only(const struct gl_debug_state *debug)
+{
+   const GLint gstack = debug->GroupStackDepth;
+   return (gstack > 0 && debug->Groups[gstack] == debug->Groups[gstack - 1]);
+}
+
+/**
+ * Make the top debug group writable.
+ */
+static bool
+debug_make_group_writable(struct gl_debug_state *debug)
+{
+   const GLint gstack = debug->GroupStackDepth;
+   const struct gl_debug_group *src = debug->Groups[gstack];
+   struct gl_debug_group *dst;
+   int s, t;
+
+   if (!debug_is_group_read_only(debug))
+      return true;
+
+   dst = malloc(sizeof(*dst));
+   if (!dst)
+      return false;
+
+   for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) {
+      for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) {
+         if (!debug_namespace_copy(&dst->Namespaces[s][t],
+                                   &src->Namespaces[s][t])) {
+            /* error path! */
+            for (t = t - 1; t >= 0; t--)
+               debug_namespace_clear(&dst->Namespaces[s][t]);
+            for (s = s - 1; s >= 0; s--) {
+               for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++)
+                  debug_namespace_clear(&dst->Namespaces[s][t]);
+            }
+            free(dst);
+            return false;
+         }
+      }
    }
 
-out:
-   return !!(state & ENABLED_BIT);
+   debug->Groups[gstack] = dst;
+
+   return true;
+}
+
+/**
+ * Free the top debug group.
+ */
+static void
+debug_clear_group(struct gl_debug_state *debug)
+{
+   const GLint gstack = debug->GroupStackDepth;
+
+   if (!debug_is_group_read_only(debug)) {
+      struct gl_debug_group *grp = debug->Groups[gstack];
+      int s, t;
+
+      for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) {
+         for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++)
+            debug_namespace_clear(&grp->Namespaces[s][t]);
+      }
+
+      free(grp);
+   }
+
+   debug->Groups[gstack] = NULL;
+}
+
+/**
+ * Loop through debug group stack tearing down states for
+ * filtering debug messages.  Then free debug output state.
+ */
+static void
+debug_destroy(struct gl_debug_state *debug)
+{
+   while (debug->GroupStackDepth > 0) {
+      debug_clear_group(debug);
+      debug->GroupStackDepth--;
+   }
+
+   debug_clear_group(debug);
+   free(debug);
 }
 
 /**
  * Sets the state of the given message source/type/ID tuple.
  */
 static void
-set_message_state(struct gl_context *ctx,
-                  enum mesa_debug_source source,
-                  enum mesa_debug_type type,
-                  GLuint id, GLboolean enabled)
+debug_set_message_enable(struct gl_debug_state *debug,
+                         enum mesa_debug_source source,
+                         enum mesa_debug_type type,
+                         GLuint id, GLboolean enabled)
 {
-   struct gl_debug_namespace *nspace =
-         &ctx->Debug.Namespaces[source][type];
-   uintptr_t state;
-
-   /* In addition to not being able to store zero as a value, HashTable also
-      can't use zero as a key. */
-   if (id)
-      state = (uintptr_t)_mesa_HashLookup(nspace->IDs, id);
-   else
-      state = nspace->ZeroID;
-
-   if (state == NOT_FOUND)
-      state = enabled ? ENABLED : DISABLED;
-   else {
-      if (enabled)
-         state |= ENABLED_BIT;
-      else
-         state &= ~ENABLED_BIT;
+   const GLint gstack = debug->GroupStackDepth;
+   struct gl_debug_namespace *ns;
+
+   debug_make_group_writable(debug);
+   ns = &debug->Groups[gstack]->Namespaces[source][type];
+
+   debug_namespace_set(ns, id, enabled);
+}
+
+/*
+ * Set the state of all message IDs found in the given intersection of
+ * 'source', 'type', and 'severity'.  The _COUNT enum can be used for
+ * GL_DONT_CARE (include all messages in the class).
+ *
+ * This requires both setting the state of all previously seen message
+ * IDs in the hash table, and setting the default state for all
+ * applicable combinations of source/type/severity, so that all the
+ * yet-unknown message IDs that may be used in the future will be
+ * impacted as if they were already known.
+ */
+static void
+debug_set_message_enable_all(struct gl_debug_state *debug,
+                             enum mesa_debug_source source,
+                             enum mesa_debug_type type,
+                             enum mesa_debug_severity severity,
+                             GLboolean enabled)
+{
+   const GLint gstack = debug->GroupStackDepth;
+   int s, t, smax, tmax;
+
+   if (source == MESA_DEBUG_SOURCE_COUNT) {
+      source = 0;
+      smax = MESA_DEBUG_SOURCE_COUNT;
+   } else {
+      smax = source+1;
    }
 
-   if (id)
-      _mesa_HashInsert(nspace->IDs, id, (void*)state);
-   else
-      nspace->ZeroID = state;
+   if (type == MESA_DEBUG_TYPE_COUNT) {
+      type = 0;
+      tmax = MESA_DEBUG_TYPE_COUNT;
+   } else {
+      tmax = type+1;
+   }
+
+   debug_make_group_writable(debug);
+
+   for (s = source; s < smax; s++) {
+      for (t = type; t < tmax; t++) {
+         struct gl_debug_namespace *nspace =
+            &debug->Groups[gstack]->Namespaces[s][t];
+         debug_namespace_set_all(nspace, severity, enabled);
+      }
+   }
+}
+
+/**
+ * Returns if the given message source/type/ID tuple is enabled.
+ */
+static bool
+debug_is_message_enabled(const struct gl_debug_state *debug,
+                         enum mesa_debug_source source,
+                         enum mesa_debug_type type,
+                         GLuint id,
+                         enum mesa_debug_severity severity)
+{
+   const GLint gstack = debug->GroupStackDepth;
+   struct gl_debug_group *grp = debug->Groups[gstack];
+   struct gl_debug_namespace *nspace = &grp->Namespaces[source][type];
+
+   if (!debug->DebugOutput)
+      return false;
+
+   return debug_namespace_get(nspace, id, severity);
 }
 
 /**
@@ -269,129 +593,242 @@ set_message_state(struct gl_context *ctx,
  * the null terminator this time.
  */
 static void
-_mesa_log_msg(struct gl_context *ctx, enum mesa_debug_source source,
-              enum mesa_debug_type type, GLuint id,
-              enum mesa_debug_severity severity, GLint len, const char *buf)
+debug_log_message(struct gl_debug_state *debug,
+                  enum mesa_debug_source source,
+                  enum mesa_debug_type type, GLuint id,
+                  enum mesa_debug_severity severity,
+                  GLsizei len, const char *buf)
 {
+   struct gl_debug_log *log = &debug->Log;
    GLint nextEmpty;
-   struct gl_debug_msg *emptySlot;
+   struct gl_debug_message *emptySlot;
 
    assert(len >= 0 && len < MAX_DEBUG_MESSAGE_LENGTH);
 
-   if (!should_log(ctx, source, type, id, severity))
+   if (log->NumMessages == MAX_DEBUG_LOGGED_MESSAGES)
       return;
 
-   if (ctx->Debug.Callback) {
-      ctx->Debug.Callback(debug_source_enums[source],
-                          debug_type_enums[type],
-                          id,
-                          debug_severity_enums[severity],
-                          len, buf, ctx->Debug.CallbackData);
-      return;
+   nextEmpty = (log->NextMessage + log->NumMessages)
+      % MAX_DEBUG_LOGGED_MESSAGES;
+   emptySlot = &log->Messages[nextEmpty];
+
+   debug_message_store(emptySlot, source, type,
+                       id, severity, len, buf);
+
+   log->NumMessages++;
+}
+
+/**
+ * Return the oldest debug message out of the log.
+ */
+static const struct gl_debug_message *
+debug_fetch_message(const struct gl_debug_state *debug)
+{
+   const struct gl_debug_log *log = &debug->Log;
+
+   return (log->NumMessages) ? &log->Messages[log->NextMessage] : NULL;
+}
+
+/**
+ * Delete the oldest debug messages out of the log.
+ */
+static void
+debug_delete_messages(struct gl_debug_state *debug, unsigned count)
+{
+   struct gl_debug_log *log = &debug->Log;
+
+   if (count > log->NumMessages)
+      count = log->NumMessages;
+
+   while (count--) {
+      struct gl_debug_message *msg = &log->Messages[log->NextMessage];
+
+      debug_message_clear(msg);
+
+      log->NumMessages--;
+      log->NextMessage++;
+      log->NextMessage %= MAX_DEBUG_LOGGED_MESSAGES;
    }
+}
 
-   if (ctx->Debug.NumMessages == MAX_DEBUG_LOGGED_MESSAGES)
-      return;
+static struct gl_debug_message *
+debug_get_group_message(struct gl_debug_state *debug)
+{
+   return &debug->GroupMessages[debug->GroupStackDepth];
+}
 
-   nextEmpty = (ctx->Debug.NextMsg + ctx->Debug.NumMessages)
-                          % MAX_DEBUG_LOGGED_MESSAGES;
-   emptySlot = &ctx->Debug.Log[nextEmpty];
+static void
+debug_push_group(struct gl_debug_state *debug)
+{
+   const GLint gstack = debug->GroupStackDepth;
 
-   assert(!emptySlot->message && !emptySlot->length);
+   /* just point to the previous stack */
+   debug->Groups[gstack + 1] = debug->Groups[gstack];
+   debug->GroupStackDepth++;
+}
 
-   emptySlot->message = malloc(len+1);
-   if (emptySlot->message) {
-      (void) strncpy(emptySlot->message, buf, (size_t)len);
-      emptySlot->message[len] = '\0';
+static void
+debug_pop_group(struct gl_debug_state *debug)
+{
+   debug_clear_group(debug);
+   debug->GroupStackDepth--;
+}
 
-      emptySlot->length = len+1;
-      emptySlot->source = source;
-      emptySlot->type = type;
-      emptySlot->id = id;
-      emptySlot->severity = severity;
-   } else {
-      static GLuint oom_msg_id = 0;
-      debug_get_id(&oom_msg_id);
 
-      /* malloc failed! */
-      emptySlot->message = out_of_memory;
-      emptySlot->length = strlen(out_of_memory)+1;
-      emptySlot->source = MESA_DEBUG_SOURCE_OTHER;
-      emptySlot->type = MESA_DEBUG_TYPE_ERROR;
-      emptySlot->id = oom_msg_id;
-      emptySlot->severity = MESA_DEBUG_SEVERITY_HIGH;
+/**
+ * Return debug state for the context.  The debug state will be allocated
+ * and initialized upon the first call.
+ */
+static struct gl_debug_state *
+_mesa_get_debug_state(struct gl_context *ctx)
+{
+   if (!ctx->Debug) {
+      ctx->Debug = debug_create();
+      if (!ctx->Debug) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "allocating debug state");
+      }
    }
 
-   if (ctx->Debug.NumMessages == 0)
-      ctx->Debug.NextMsgLength = ctx->Debug.Log[ctx->Debug.NextMsg].length;
+   return ctx->Debug;
+}
+
+/**
+ * Set the integer debug state specified by \p pname.  This can be called from
+ * _mesa_set_enable for example.
+ */
+bool
+_mesa_set_debug_state_int(struct gl_context *ctx, GLenum pname, GLint val)
+{
+   struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
+
+   if (!debug)
+      return false;
+
+   switch (pname) {
+   case GL_DEBUG_OUTPUT:
+      debug->DebugOutput = (val != 0);
+      break;
+   case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB:
+      debug->SyncOutput = (val != 0);
+      break;
+   default:
+      assert(!"unknown debug output param");
+      break;
+   }
 
-   ctx->Debug.NumMessages++;
+   return true;
 }
 
 /**
- * Pop the oldest debug message out of the log.
- * Writes the message string, including the null terminator, into 'buf',
- * using up to 'bufSize' bytes. If 'bufSize' is too small, or
- * if 'buf' is NULL, nothing is written.
- *
- * Returns the number of bytes written on success, or when 'buf' is NULL,
- * the number that would have been written. A return value of 0
- * indicates failure.
+ * Query the integer debug state specified by \p pname.  This can be called
+ * _mesa_GetIntegerv for example.
  */
-static GLsizei
-_mesa_get_msg(struct gl_context *ctx, GLenum *source, GLenum *type,
-              GLuint *id, GLenum *severity, GLsizei bufSize, char *buf)
+GLint
+_mesa_get_debug_state_int(struct gl_context *ctx, GLenum pname)
 {
-   struct gl_debug_msg *msg;
-   GLsizei length;
+   struct gl_debug_state *debug;
+   GLint val;
 
-   if (ctx->Debug.NumMessages == 0)
+   debug = ctx->Debug;
+   if (!debug)
       return 0;
 
-   msg = &ctx->Debug.Log[ctx->Debug.NextMsg];
-   length = msg->length;
+   switch (pname) {
+   case GL_DEBUG_OUTPUT:
+      val = debug->DebugOutput;
+      break;
+   case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB:
+      val = debug->SyncOutput;
+      break;
+   case GL_DEBUG_LOGGED_MESSAGES:
+      val = debug->Log.NumMessages;
+      break;
+   case GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH:
+      val = (debug->Log.NumMessages) ?
+         debug->Log.Messages[debug->Log.NextMessage].length : 0;
+      break;
+   case GL_DEBUG_GROUP_STACK_DEPTH:
+      val = debug->GroupStackDepth;
+      break;
+   default:
+      assert(!"unknown debug output param");
+      val = 0;
+      break;
+   }
 
-   assert(length > 0 && length == ctx->Debug.NextMsgLength);
+   return val;
+}
 
-   if (bufSize < length && buf != NULL)
-      return 0;
+/**
+ * Query the pointer debug state specified by \p pname.  This can be called
+ * _mesa_GetPointerv for example.
+ */
+void *
+_mesa_get_debug_state_ptr(struct gl_context *ctx, GLenum pname)
+{
+   struct gl_debug_state *debug;
+   void *val;
+
+   debug = ctx->Debug;
+   if (!debug)
+      return NULL;
 
-   if (severity)
-      *severity = debug_severity_enums[msg->severity];
-   if (source)
-      *source = debug_source_enums[msg->source];
-   if (type)
-      *type = debug_type_enums[msg->type];
-   if (id)
-      *id = msg->id;
-
-   if (buf) {
-      assert(msg->message[length-1] == '\0');
-      (void) strncpy(buf, msg->message, (size_t)length);
+   switch (pname) {
+   case GL_DEBUG_CALLBACK_FUNCTION_ARB:
+      val = (void *) debug->Callback;
+      break;
+   case GL_DEBUG_CALLBACK_USER_PARAM_ARB:
+      val = (void *) debug->CallbackData;
+      break;
+   default:
+      assert(!"unknown debug output param");
+      val = NULL;
+      break;
    }
 
-   if (msg->message != (char*)out_of_memory)
-      free(msg->message);
-   msg->message = NULL;
-   msg->length = 0;
+   return val;
+}
 
-   ctx->Debug.NumMessages--;
-   ctx->Debug.NextMsg++;
-   ctx->Debug.NextMsg %= MAX_DEBUG_LOGGED_MESSAGES;
-   ctx->Debug.NextMsgLength = ctx->Debug.Log[ctx->Debug.NextMsg].length;
 
-   return length;
+/**
+ * Log a client or driver debug message.
+ */
+static void
+log_msg(struct gl_context *ctx, enum mesa_debug_source source,
+        enum mesa_debug_type type, GLuint id,
+        enum mesa_debug_severity severity, GLint len, const char *buf)
+{
+   struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
+
+   if (!debug)
+      return;
+
+   if (!debug_is_message_enabled(debug, source, type, id, severity))
+      return;
+
+   if (debug->Callback) {
+       GLenum gl_type = debug_type_enums[type];
+       GLenum gl_severity = debug_severity_enums[severity];
+
+      debug->Callback(debug_source_enums[source], gl_type, id, gl_severity,
+                      len, buf, debug->CallbackData);
+      return;
+   }
+
+   debug_log_message(debug, source, type, id, severity, len, buf);
 }
 
+
 /**
  * Verify that source, type, and severity are valid enums.
- * glDebugMessageInsertARB only accepts two values for 'source',
- * and glDebugMessageControlARB will additionally accept GL_DONT_CARE
- * in any parameter, so handle those cases specially.
+ *
+ * The 'caller' param is used for handling values available
+ * only in glDebugMessageInsert or glDebugMessageControl
  */
 static GLboolean
 validate_params(struct gl_context *ctx, unsigned caller,
-                GLenum source, GLenum type, GLenum severity)
+                const char *callerstr, GLenum source, GLenum type,
+                GLenum severity)
 {
 #define INSERT 1
 #define CONTROL 2
@@ -405,9 +842,13 @@ validate_params(struct gl_context *ctx, unsigned caller,
    case GL_DEBUG_SOURCE_OTHER_ARB:
       if (caller != INSERT)
          break;
+      else
+         goto error;
    case GL_DONT_CARE:
       if (caller == CONTROL)
          break;
+      else
+         goto error;
    default:
       goto error;
    }
@@ -419,10 +860,15 @@ validate_params(struct gl_context *ctx, unsigned caller,
    case GL_DEBUG_TYPE_PERFORMANCE_ARB:
    case GL_DEBUG_TYPE_PORTABILITY_ARB:
    case GL_DEBUG_TYPE_OTHER_ARB:
+   case GL_DEBUG_TYPE_MARKER:
       break;
+   case GL_DEBUG_TYPE_PUSH_GROUP:
+   case GL_DEBUG_TYPE_POP_GROUP:
    case GL_DONT_CARE:
       if (caller == CONTROL)
          break;
+      else
+         goto error;
    default:
       goto error;
    }
@@ -431,301 +877,280 @@ validate_params(struct gl_context *ctx, unsigned caller,
    case GL_DEBUG_SEVERITY_HIGH_ARB:
    case GL_DEBUG_SEVERITY_MEDIUM_ARB:
    case GL_DEBUG_SEVERITY_LOW_ARB:
+   case GL_DEBUG_SEVERITY_NOTIFICATION:
       break;
    case GL_DONT_CARE:
       if (caller == CONTROL)
          break;
+      else
+         goto error;
    default:
       goto error;
    }
    return GL_TRUE;
 
 error:
-   {
-      const char *callerstr;
-      if (caller == INSERT)
-         callerstr = "glDebugMessageInsertARB";
-      else if (caller == CONTROL)
-         callerstr = "glDebugMessageControlARB";
-      else
-         return GL_FALSE;
+   _mesa_error(ctx, GL_INVALID_ENUM, "bad values passed to %s"
+               "(source=0x%x, type=0x%x, severity=0x%x)", callerstr,
+               source, type, severity);
 
-      _mesa_error( ctx, GL_INVALID_ENUM, "bad values passed to %s"
-                  "(source=0x%x, type=0x%x, severity=0x%x)", callerstr,
-                  source, type, severity);
-   }
    return GL_FALSE;
 }
 
+
+static GLboolean
+validate_length(struct gl_context *ctx, const char *callerstr, GLsizei length)
+{
+   if (length >= MAX_DEBUG_MESSAGE_LENGTH) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                 "%s(length=%d, which is not less than "
+                 "GL_MAX_DEBUG_MESSAGE_LENGTH=%d)", callerstr, length,
+                 MAX_DEBUG_MESSAGE_LENGTH);
+      return GL_FALSE;
+   }
+
+   return GL_TRUE;
+}
+
+
 void GLAPIENTRY
-_mesa_DebugMessageInsertARB(GLenum source, GLenum type, GLuint id,
-                            GLenum severity, GLint length,
-                            const GLcharARB* buf)
+_mesa_DebugMessageInsert(GLenum source, GLenum type, GLuint id,
+                         GLenum severity, GLint length,
+                         const GLchar *buf)
 {
+   const char *callerstr = "glDebugMessageInsert";
+
    GET_CURRENT_CONTEXT(ctx);
 
-   if (!validate_params(ctx, INSERT, source, type, severity))
+   if (!validate_params(ctx, INSERT, callerstr, source, type, severity))
       return; /* GL_INVALID_ENUM */
 
    if (length < 0)
       length = strlen(buf);
+   if (!validate_length(ctx, callerstr, length))
+      return; /* GL_INVALID_VALUE */
 
-   if (length >= MAX_DEBUG_MESSAGE_LENGTH) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glDebugMessageInsertARB"
-                 "(length=%d, which is not less than "
-                 "GL_MAX_DEBUG_MESSAGE_LENGTH_ARB=%d)", length,
-                 MAX_DEBUG_MESSAGE_LENGTH);
-      return;
-   }
-
-   _mesa_log_msg(ctx,
-                 gl_enum_to_debug_source(source),
-                 gl_enum_to_debug_type(type), id,
-                 gl_enum_to_debug_severity(severity), length, buf);
+   log_msg(ctx, gl_enum_to_debug_source(source),
+           gl_enum_to_debug_type(type), id,
+           gl_enum_to_debug_severity(severity),
+           length, buf);
 }
 
+
 GLuint GLAPIENTRY
-_mesa_GetDebugMessageLogARB(GLuint count, GLsizei logSize, GLenum* sources,
-                            GLenum* types, GLenum* ids, GLenum* severities,
-                            GLsizei* lengths, GLcharARB* messageLog)
+_mesa_GetDebugMessageLog(GLuint count, GLsizei logSize, GLenum *sources,
+                         GLenum *types, GLenum *ids, GLenum *severities,
+                         GLsizei *lengths, GLchar *messageLog)
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_debug_state *debug;
    GLuint ret;
 
    if (!messageLog)
       logSize = 0;
 
    if (logSize < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetDebugMessageLogARB"
-                 "(logSize=%d : logSize must not be negative)", logSize);
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glGetDebugMessageLog(logSize=%d : logSize must not be"
+                  " negative)", logSize);
       return 0;
    }
 
+   debug = _mesa_get_debug_state(ctx);
+   if (!debug)
+      return 0;
+
    for (ret = 0; ret < count; ret++) {
-      GLsizei written = _mesa_get_msg(ctx, sources, types, ids, severities,
-                                      logSize, messageLog);
-      if (!written)
+      const struct gl_debug_message *msg = debug_fetch_message(debug);
+
+      if (!msg)
+         break;
+
+      if (logSize < msg->length && messageLog != NULL)
          break;
 
       if (messageLog) {
-         messageLog += written;
-         logSize -= written;
-      }
-      if (lengths) {
-         *lengths = written;
-         lengths++;
+         assert(msg->message[msg->length-1] == '\0');
+         (void) strncpy(messageLog, msg->message, (size_t)msg->length);
+
+         messageLog += msg->length;
+         logSize -= msg->length;
       }
 
+      if (lengths)
+         *lengths++ = msg->length;
       if (severities)
-         severities++;
+         *severities++ = debug_severity_enums[msg->severity];
       if (sources)
-         sources++;
+         *sources++ = debug_source_enums[msg->source];
       if (types)
-         types++;
+         *types++ = debug_type_enums[msg->type];
       if (ids)
-         ids++;
+         *ids++ = msg->id;
+
+      debug_delete_messages(debug, 1);
    }
 
    return ret;
 }
 
-/**
- * Set the state of all message IDs found in the given intersection of
- * 'source', 'type', and 'severity'.  The _COUNT enum can be used for
- * GL_DONT_CARE (include all messages in the class).
- *
- * This requires both setting the state of all previously seen message
- * IDs in the hash table, and setting the default state for all
- * applicable combinations of source/type/severity, so that all the
- * yet-unknown message IDs that may be used in the future will be
- * impacted as if they were already known.
- */
-static void
-control_messages(struct gl_context *ctx,
-                 enum mesa_debug_source source,
-                 enum mesa_debug_type type,
-                 enum mesa_debug_severity severity,
-                 GLboolean enabled)
+
+void GLAPIENTRY
+_mesa_DebugMessageControl(GLenum gl_source, GLenum gl_type,
+                          GLenum gl_severity, GLsizei count,
+                          const GLuint *ids, GLboolean enabled)
 {
-   int s, t, sev, smax, tmax, sevmax;
+   GET_CURRENT_CONTEXT(ctx);
+   enum mesa_debug_source source = gl_enum_to_debug_source(gl_source);
+   enum mesa_debug_type type = gl_enum_to_debug_type(gl_type);
+   enum mesa_debug_severity severity = gl_enum_to_debug_severity(gl_severity);
+   const char *callerstr = "glDebugMessageControl";
+   struct gl_debug_state *debug;
 
-   if (source == MESA_DEBUG_SOURCE_COUNT) {
-      source = 0;
-      smax = MESA_DEBUG_SOURCE_COUNT;
-   } else {
-      smax = source+1;
+   if (count < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "%s(count=%d : count must not be negative)", callerstr,
+                  count);
+      return;
    }
 
-   if (type == MESA_DEBUG_TYPE_COUNT) {
-      type = 0;
-      tmax = MESA_DEBUG_TYPE_COUNT;
-   } else {
-      tmax = type+1;
-   }
+   if (!validate_params(ctx, CONTROL, callerstr, gl_source, gl_type,
+                        gl_severity))
+      return; /* GL_INVALID_ENUM */
 
-   if (severity == MESA_DEBUG_SEVERITY_COUNT) {
-      severity = 0;
-      sevmax = MESA_DEBUG_SEVERITY_COUNT;
-   } else {
-      sevmax = severity+1;
+   if (count && (gl_severity != GL_DONT_CARE || gl_type == GL_DONT_CARE
+                 || gl_source == GL_DONT_CARE)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "%s(When passing an array of ids, severity must be"
+         " GL_DONT_CARE, and source and type must not be GL_DONT_CARE.",
+                  callerstr);
+      return;
    }
 
-   for (sev = severity; sev < sevmax; sev++)
-      for (s = source; s < smax; s++)
-         for (t = type; t < tmax; t++) {
-            struct simple_node *node;
-            struct gl_debug_severity *entry;
+   debug = _mesa_get_debug_state(ctx);
+   if (!debug)
+      return;
 
-            /* change the default for IDs we've never seen before. */
-            ctx->Debug.Defaults[sev][s][t] = enabled;
+   if (count) {
+      GLsizei i;
+      for (i = 0; i < count; i++)
+         debug_set_message_enable(debug, source, type, ids[i], enabled);
+   }
+   else {
+      debug_set_message_enable_all(debug, source, type, severity, enabled);
+   }
+}
 
-            /* Now change the state of IDs we *have* seen... */
-            foreach(node, &ctx->Debug.Namespaces[s][t].Severity[sev]) {
-               entry = (struct gl_debug_severity *)node;
-               set_message_state(ctx, s, t, entry->ID, enabled);
-            }
-         }
+
+void GLAPIENTRY
+_mesa_DebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
+   if (debug) {
+      debug->Callback = callback;
+      debug->CallbackData = userParam;
+   }
 }
 
-/**
- * Debugging-message namespaces with the source APPLICATION or THIRD_PARTY
- * require special handling, since the IDs in them are controlled by clients,
- * not the OpenGL implementation.
- *
- * 'count' is the length of the array 'ids'. If 'count' is nonzero, all
- * the given IDs in the namespace defined by 'esource' and 'etype'
- * will be affected.
- *
- * If 'count' is zero, this sets the state of all IDs that match
- * the combination of 'esource', 'etype', and 'eseverity'.
- */
-static void
-control_app_messages(struct gl_context *ctx, GLenum esource, GLenum etype,
-                     GLenum eseverity, GLsizei count, const GLuint *ids,
-                     GLboolean enabled)
+
+void GLAPIENTRY
+_mesa_PushDebugGroup(GLenum source, GLuint id, GLsizei length,
+                     const GLchar *message)
 {
-   GLsizei i;
-   enum mesa_debug_source source = gl_enum_to_debug_source(esource);
-   enum mesa_debug_type type = gl_enum_to_debug_type(etype);
-   enum mesa_debug_severity severity = gl_enum_to_debug_severity(eseverity);
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
+   const char *callerstr = "glPushDebugGroup";
+   struct gl_debug_message *emptySlot;
 
-   if (count)
-      assert(severity == MESA_DEBUG_SEVERITY_COUNT
-             && type != MESA_DEBUG_TYPE_COUNT
-             && source != MESA_DEBUG_SOURCE_COUNT);
+   if (!debug)
+      return;
 
-   for (i = 0; i < count; i++)
-      set_message_state(ctx, source, type, ids[i], enabled);
+   if (debug->GroupStackDepth >= MAX_DEBUG_GROUP_STACK_DEPTH-1) {
+      _mesa_error(ctx, GL_STACK_OVERFLOW, "%s", callerstr);
+      return;
+   }
 
-   if (count)
+   switch(source) {
+   case GL_DEBUG_SOURCE_APPLICATION:
+   case GL_DEBUG_SOURCE_THIRD_PARTY:
+      break;
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM, "bad value passed to %s"
+                  "(source=0x%x)", callerstr, source);
       return;
+   }
 
-   control_messages(ctx, source, type, severity, enabled);
+   if (length < 0)
+      length = strlen(message);
+   if (!validate_length(ctx, callerstr, length))
+      return; /* GL_INVALID_VALUE */
+
+   log_msg(ctx, gl_enum_to_debug_source(source),
+           MESA_DEBUG_TYPE_PUSH_GROUP, id,
+           MESA_DEBUG_SEVERITY_NOTIFICATION, length,
+           message);
+
+   /* pop reuses the message details from push so we store this */
+   emptySlot = debug_get_group_message(debug);
+   debug_message_store(emptySlot,
+                       gl_enum_to_debug_source(source),
+                       gl_enum_to_debug_type(GL_DEBUG_TYPE_PUSH_GROUP),
+                       id,
+                       gl_enum_to_debug_severity(GL_DEBUG_SEVERITY_NOTIFICATION),
+                       length, message);
+
+   debug_push_group(debug);
 }
 
+
 void GLAPIENTRY
-_mesa_DebugMessageControlARB(GLenum gl_source, GLenum gl_type,
-                             GLenum gl_severity,
-                             GLsizei count, const GLuint *ids,
-                             GLboolean enabled)
+_mesa_PopDebugGroup(void)
 {
-   enum mesa_debug_source source;
-   enum mesa_debug_type type;
-   enum mesa_debug_severity severity;
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
+   const char *callerstr = "glPopDebugGroup";
+   struct gl_debug_message *gdmessage;
 
-   if (count < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glDebugMessageControlARB"
-                 "(count=%d : count must not be negative)", count);
+   if (!debug)
       return;
-   }
 
-   if (!validate_params(ctx, CONTROL, gl_source, gl_type, gl_severity))
-      return; /* GL_INVALID_ENUM */
-
-   if (count && (gl_severity != GL_DONT_CARE || gl_type == GL_DONT_CARE
-                 || gl_source == GL_DONT_CARE)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glDebugMessageControlARB"
-                 "(When passing an array of ids, severity must be"
-         " GL_DONT_CARE, and source and type must not be GL_DONT_CARE.");
+   if (debug->GroupStackDepth <= 0) {
+      _mesa_error(ctx, GL_STACK_UNDERFLOW, "%s", callerstr);
       return;
    }
 
-   source = gl_enum_to_debug_severity(gl_source);
-   type = gl_enum_to_debug_severity(gl_type);
-   severity = gl_enum_to_debug_severity(gl_severity);
+   debug_pop_group(debug);
 
-   control_app_messages(ctx, source, type, severity, count, ids, enabled);
-}
+   gdmessage = debug_get_group_message(debug);
+   log_msg(ctx, gdmessage->source,
+           gl_enum_to_debug_type(GL_DEBUG_TYPE_POP_GROUP),
+           gdmessage->id,
+           gl_enum_to_debug_severity(GL_DEBUG_SEVERITY_NOTIFICATION),
+           gdmessage->length, gdmessage->message);
 
-void GLAPIENTRY
-_mesa_DebugMessageCallbackARB(GLDEBUGPROCARB callback, const GLvoid *userParam)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ctx->Debug.Callback = callback;
-   ctx->Debug.CallbackData = (void *) userParam;
+   debug_message_clear(gdmessage);
 }
 
+
 void
 _mesa_init_errors(struct gl_context *ctx)
 {
-   int s, t, sev;
-
-   ctx->Debug.Callback = NULL;
-   ctx->Debug.SyncOutput = GL_FALSE;
-   ctx->Debug.Log[0].length = 0;
-   ctx->Debug.NumMessages = 0;
-   ctx->Debug.NextMsg = 0;
-   ctx->Debug.NextMsgLength = 0;
-
-   /* Enable all the messages with severity HIGH or MEDIUM by default. */
-   memset(ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_HIGH], GL_TRUE,
-          sizeof ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_HIGH]);
-   memset(ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_MEDIUM], GL_TRUE,
-          sizeof ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_MEDIUM]);
-   memset(ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_LOW], GL_FALSE,
-          sizeof ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_LOW]);
-
-   /* Initialize state for filtering known debug messages. */
-   for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++)
-      for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) {
-         ctx->Debug.Namespaces[s][t].IDs = _mesa_NewHashTable();
-         assert(ctx->Debug.Namespaces[s][t].IDs);
-
-         for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++)
-            make_empty_list(&ctx->Debug.Namespaces[s][t].Severity[sev]);
-      }
+   /* no-op */
 }
 
-static void
-do_nothing(GLuint key, void *data, void *userData)
-{
-}
 
 void
 _mesa_free_errors_data(struct gl_context *ctx)
 {
-   enum mesa_debug_type t;
-   enum mesa_debug_source s;
-   enum mesa_debug_severity sev;
-
-   /* Tear down state for filtering debug messages. */
-   for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++)
-      for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) {
-         _mesa_HashDeleteAll(ctx->Debug.Namespaces[s][t].IDs, do_nothing, NULL);
-         _mesa_DeleteHashTable(ctx->Debug.Namespaces[s][t].IDs);
-         for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) {
-            struct simple_node *node, *tmp;
-            struct gl_debug_severity *entry;
-
-            foreach_s(node, tmp, &ctx->Debug.Namespaces[s][t].Severity[sev]) {
-               entry = (struct gl_debug_severity *)node;
-               free(entry);
-            }
-         }
-      }
+   if (ctx->Debug) {
+      debug_destroy(ctx->Debug);
+      /* set to NULL just in case it is used before context is completely gone. */
+      ctx->Debug = NULL;
+   }
 }
 
+
 /**********************************************************************/
 /** \name Diagnostics */
 /*@{*/
@@ -781,6 +1206,7 @@ output_if_debug(const char *prefixString, const char *outputString,
    }
 }
 
+
 /**
  * When a new type of error is recorded, print a message describing
  * previous errors which were accumulated.
@@ -848,11 +1274,12 @@ _mesa_problem( const struct gl_context *ctx, const char *fmtString, ... )
       _mesa_vsnprintf( str, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args );
       va_end( args );
       fprintf(stderr, "Mesa %s implementation error: %s\n",
-              MESA_VERSION_STRING, str);
-      fprintf(stderr, "Please report at bugs.freedesktop.org\n");
+              PACKAGE_VERSION, str);
+      fprintf(stderr, "Please report at " PACKAGE_BUGREPORT "\n");
    }
 }
 
+
 static GLboolean
 should_output(struct gl_context *ctx, GLenum error, const char *fmtString)
 {
@@ -889,6 +1316,7 @@ should_output(struct gl_context *ctx, GLenum error, const char *fmtString)
    return GL_FALSE;
 }
 
+
 void
 _mesa_gl_debug(struct gl_context *ctx,
                GLuint *id,
@@ -906,8 +1334,7 @@ _mesa_gl_debug(struct gl_context *ctx,
    len = _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);
    va_end(args);
 
-   _mesa_log_msg(ctx, MESA_DEBUG_SOURCE_API, type,
-                 *id, severity, len, s);
+   log_msg(ctx, MESA_DEBUG_SOURCE_API, type, *id, severity, len, s);
 }
 
 
@@ -927,13 +1354,24 @@ void
 _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... )
 {
    GLboolean do_output, do_log;
+   /* Ideally this would be set up by the caller, so that we had proper IDs
+    * per different message.
+    */
+   static GLuint error_msg_id = 0;
+
+   debug_get_id(&error_msg_id);
 
    do_output = should_output(ctx, error, fmtString);
-   do_log = should_log(ctx,
-                       MESA_DEBUG_SOURCE_API,
-                       MESA_DEBUG_TYPE_ERROR,
-                       API_ERROR_UNKNOWN,
-                       MESA_DEBUG_SEVERITY_HIGH);
+   if (ctx->Debug) {
+      do_log = debug_is_message_enabled(ctx->Debug,
+                                        MESA_DEBUG_SOURCE_API,
+                                        MESA_DEBUG_TYPE_ERROR,
+                                        error_msg_id,
+                                        MESA_DEBUG_SEVERITY_HIGH);
+   }
+   else {
+      do_log = GL_FALSE;
+   }
 
    if (do_output || do_log) {
       char s[MAX_DEBUG_MESSAGE_LENGTH], s2[MAX_DEBUG_MESSAGE_LENGTH];
@@ -946,7 +1384,8 @@ _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... )
 
       if (len >= MAX_DEBUG_MESSAGE_LENGTH) {
          /* Too long error message. Whoever calls _mesa_error should use
-          * shorter strings. */
+          * shorter strings.
+          */
          ASSERT(0);
          return;
       }
@@ -966,11 +1405,8 @@ _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... )
 
       /* Log the error via ARB_debug_output if needed.*/
       if (do_log) {
-         _mesa_log_msg(ctx,
-                       MESA_DEBUG_SOURCE_API,
-                       MESA_DEBUG_TYPE_ERROR,
-                       API_ERROR_UNKNOWN,
-                       MESA_DEBUG_SEVERITY_HIGH, len, s2);
+         log_msg(ctx, MESA_DEBUG_SOURCE_API, MESA_DEBUG_TYPE_ERROR,
+                 error_msg_id, MESA_DEBUG_SEVERITY_HIGH, len, s2);
       }
    }
 
@@ -978,6 +1414,12 @@ _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... )
    _mesa_record_error(ctx, error);
 }
 
+void
+_mesa_error_no_memory(const char *caller)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_error(ctx, GL_OUT_OF_MEMORY, "out of memory in %s", caller);
+}
 
 /**
  * Report debug information.  Print error message to stderr via fprintf().
@@ -1027,7 +1469,7 @@ _mesa_shader_debug( struct gl_context *ctx, GLenum type, GLuint *id,
    if (len >= MAX_DEBUG_MESSAGE_LENGTH)
       len = MAX_DEBUG_MESSAGE_LENGTH - 1;
 
-   _mesa_log_msg(ctx, source, type, *id, severity, len, msg);
+   log_msg(ctx, source, type, *id, severity, len, msg);
 }
 
 /*@}*/