Merge commit '8b0fb1c152fe191768953aa8c77b89034a377f83' into vulkan

This pulls in Rob Clark's const_index changes for NIR

13 files changed, 1508 insertions, 1368 deletions

diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c
index 8b415ed6019..9388a1ca51d 100644
--- a/src/mesa/main/context.c
+++ b/src/mesa/main/context.c
@@ -89,6 +89,7 @@
 #include "context.h"
 #include "cpuinfo.h"
 #include "debug.h"
+#include "debug_output.h"
 #include "depth.h"
 #include "dlist.h"
 #include "eval.h"
@@ -814,8 +815,8 @@ init_attrib_groups(struct gl_context *ctx)
    _mesa_init_current( ctx );
    _mesa_init_depth( ctx );
    _mesa_init_debug( ctx );
+   _mesa_init_debug_output( ctx );
    _mesa_init_display_list( ctx );
-   _mesa_init_errors( ctx );
    _mesa_init_eval( ctx );
    _mesa_init_fbobjects( ctx );
    _mesa_init_feedback( ctx );
diff --git a/src/mesa/main/debug_output.c b/src/mesa/main/debug_output.c
new file mode 100644
index 00000000000..10ee6757cc1
--- /dev/null
+++ b/src/mesa/main/debug_output.c
@@ -0,0 +1,1301 @@
+/*
+ * Mesa 3-D graphics library
+ *
+ * Copyright (C) 1999-2016  Brian Paul, et al   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "context.h"
+#include "debug_output.h"
+#include "dispatch.h"
+#include "enums.h"
+#include "imports.h"
+#include "hash.h"
+#include "mtypes.h"
+#include "version.h"
+#include "util/hash_table.h"
+#include "util/simple_list.h"
+
+
+static mtx_t DynamicIDMutex = _MTX_INITIALIZER_NP;
+static GLuint NextDynamicID = 1;
+
+
+/**
+ * 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;
+   /* length as given by the user - if message was explicitly null terminated,
+    * length can be negative */
+   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 CurrentGroup; // GroupStackDepth - 1
+
+   struct gl_debug_log Log;
+};
+
+
+static char out_of_memory[] = "Debugging error: out of memory";
+
+static const GLenum debug_source_enums[] = {
+   GL_DEBUG_SOURCE_API,
+   GL_DEBUG_SOURCE_WINDOW_SYSTEM,
+   GL_DEBUG_SOURCE_SHADER_COMPILER,
+   GL_DEBUG_SOURCE_THIRD_PARTY,
+   GL_DEBUG_SOURCE_APPLICATION,
+   GL_DEBUG_SOURCE_OTHER,
+};
+
+static const GLenum debug_type_enums[] = {
+   GL_DEBUG_TYPE_ERROR,
+   GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR,
+   GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR,
+   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)
+{
+   unsigned i;
+
+   for (i = 0; i < ARRAY_SIZE(debug_source_enums); i++) {
+      if (debug_source_enums[i] == e)
+         break;
+   }
+   return i;
+}
+
+static enum mesa_debug_type
+gl_enum_to_debug_type(GLenum e)
+{
+   unsigned i;
+
+   for (i = 0; i < ARRAY_SIZE(debug_type_enums); i++) {
+      if (debug_type_enums[i] == e)
+         break;
+   }
+   return i;
+}
+
+static enum mesa_debug_severity
+gl_enum_to_debug_severity(GLenum e)
+{
+   unsigned i;
+
+   for (i = 0; i < ARRAY_SIZE(debug_severity_enums); i++) {
+      if (debug_severity_enums[i] == e)
+         break;
+   }
+   return i;
+}
+
+
+/**
+ * Handles generating a GL_ARB_debug_output message ID generated by the GL or
+ * GLSL compiler.
+ *
+ * The GL API has this "ID" mechanism, where the intention is to allow a
+ * client to filter in/out messages based on source, type, and ID.  Of course,
+ * building a giant enum list of all debug output messages that Mesa might
+ * generate is ridiculous, so instead we have our caller pass us a pointer to
+ * static storage where the ID should get stored.  This ID will be shared
+ * across all contexts for that message (which seems like a desirable
+ * property, even if it's not expected by the spec), but note that it won't be
+ * the same between executions if messages aren't generated in the same order.
+ */
+void
+_mesa_debug_get_id(GLuint *id)
+{
+   if (!(*id)) {
+      mtx_lock(&DynamicIDMutex);
+      if (!(*id))
+         *id = NextDynamicID++;
+      mtx_unlock(&DynamicIDMutex);
+   }
+}
+
+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)
+{
+   GLsizei length = len;
+
+   assert(!msg->message && !msg->length);
+
+   if (length < 0)
+      length = strlen(buf);
+
+   msg->message = malloc(length+1);
+   if (msg->message) {
+      (void) strncpy(msg->message, buf, (size_t)length);
+      msg->message[length] = '\0';
+
+      msg->length = len;
+      msg->source = source;
+      msg->type = type;
+      msg->id = id;
+      msg->severity = severity;
+   } else {
+      static GLuint oom_msg_id = 0;
+      _mesa_debug_get_id(&oom_msg_id);
+
+      /* malloc failed! */
+      msg->message = out_of_memory;
+      msg->length = -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_MEDIUM ) |
+                      (1 << MESA_DEBUG_SEVERITY_HIGH) |
+                      (1 << MESA_DEBUG_SEVERITY_NOTIFICATION);
+}
+
+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.
+ */
+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;
+}
+
+/**
+ * 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 void
+debug_namespace_set_all(struct gl_debug_namespace *ns,
+                        enum mesa_debug_severity severity,
+                        bool enabled)
+{
+   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);
+      }
+   }
+}
+
+/**
+ * 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 = ns->DefaultState;
+   foreach(node, &ns->Elements) {
+      struct gl_debug_element *elem = (struct gl_debug_element *) node;
+
+      if (elem->ID == id) {
+         state = elem->State;
+         break;
+      }
+   }
+
+   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->CurrentGroup;
+   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->CurrentGroup;
+   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;
+         }
+      }
+   }
+
+   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->CurrentGroup;
+
+   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->CurrentGroup > 0) {
+      debug_clear_group(debug);
+      debug->CurrentGroup--;
+   }
+
+   debug_clear_group(debug);
+   free(debug);
+}
+
+/**
+ * Sets the state of the given message source/type/ID tuple.
+ */
+static void
+debug_set_message_enable(struct gl_debug_state *debug,
+                         enum mesa_debug_source source,
+                         enum mesa_debug_type type,
+                         GLuint id, GLboolean enabled)
+{
+   const GLint gstack = debug->CurrentGroup;
+   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->CurrentGroup;
+   int s, t, smax, tmax;
+
+   if (source == MESA_DEBUG_SOURCE_COUNT) {
+      source = 0;
+      smax = MESA_DEBUG_SOURCE_COUNT;
+   } else {
+      smax = source+1;
+   }
+
+   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.
+ */
+bool
+_mesa_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->CurrentGroup;
+   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);
+}
+
+/**
+ * 'buf' is not necessarily a null-terminated string. When logging, copy
+ * 'len' characters from it, store them in a new, null-terminated string,
+ * and remember the number of bytes used by that string, *including*
+ * the null terminator this time.
+ */
+static void
+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_message *emptySlot;
+
+   assert(len < MAX_DEBUG_MESSAGE_LENGTH);
+
+   if (log->NumMessages == MAX_DEBUG_LOGGED_MESSAGES)
+      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, int 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;
+   }
+}
+
+static struct gl_debug_message *
+debug_get_group_message(struct gl_debug_state *debug)
+{
+   return &debug->GroupMessages[debug->CurrentGroup];
+}
+
+static void
+debug_push_group(struct gl_debug_state *debug)
+{
+   const GLint gstack = debug->CurrentGroup;
+
+   /* just point to the previous stack */
+   debug->Groups[gstack + 1] = debug->Groups[gstack];
+   debug->CurrentGroup++;
+}
+
+static void
+debug_pop_group(struct gl_debug_state *debug)
+{
+   debug_clear_group(debug);
+   debug->CurrentGroup--;
+}
+
+
+/**
+ * Lock and return debug state for the context.  The debug state will be
+ * allocated and initialized upon the first call.  When NULL is returned, the
+ * debug state is not locked.
+ */
+static struct gl_debug_state *
+_mesa_lock_debug_state(struct gl_context *ctx)
+{
+   mtx_lock(&ctx->DebugMutex);
+
+   if (!ctx->Debug) {
+      ctx->Debug = debug_create();
+      if (!ctx->Debug) {
+         GET_CURRENT_CONTEXT(cur);
+         mtx_unlock(&ctx->DebugMutex);
+
+         /*
+          * This function may be called from other threads.  When that is the
+          * case, we cannot record this OOM error.
+          */
+         if (ctx == cur)
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "allocating debug state");
+
+         return NULL;
+      }
+   }
+
+   return ctx->Debug;
+}
+
+static void
+_mesa_unlock_debug_state(struct gl_context *ctx)
+{
+   mtx_unlock(&ctx->DebugMutex);
+}
+
+/**
+ * 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_lock_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;
+   }
+
+   _mesa_unlock_debug_state(ctx);
+
+   return true;
+}
+
+/**
+ * Query the integer debug state specified by \p pname.  This can be called
+ * _mesa_GetIntegerv for example.
+ */
+GLint
+_mesa_get_debug_state_int(struct gl_context *ctx, GLenum pname)
+{
+   struct gl_debug_state *debug;
+   GLint val;
+
+   mtx_lock(&ctx->DebugMutex);
+   debug = ctx->Debug;
+   if (!debug) {
+      mtx_unlock(&ctx->DebugMutex);
+      return 0;
+   }
+
+   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->CurrentGroup + 1;
+      break;
+   default:
+      assert(!"unknown debug output param");
+      val = 0;
+      break;
+   }
+
+   mtx_unlock(&ctx->DebugMutex);
+
+   return val;
+}
+
+/**
+ * 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;
+
+   mtx_lock(&ctx->DebugMutex);
+   debug = ctx->Debug;
+   if (!debug) {
+      mtx_unlock(&ctx->DebugMutex);
+      return NULL;
+   }
+
+   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;
+   }
+
+   mtx_unlock(&ctx->DebugMutex);
+
+   return val;
+}
+
+/**
+ * Insert a debug message.  The mutex is assumed to be locked, and will be
+ * unlocked by this call.
+ */
+static void
+log_msg_locked_and_unlock(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 = ctx->Debug;
+
+   if (!_mesa_debug_is_message_enabled(debug, source, type, id, severity)) {
+      _mesa_unlock_debug_state(ctx);
+      return;
+   }
+
+   if (ctx->Debug->Callback) {
+      GLenum gl_source = debug_source_enums[source];
+      GLenum gl_type = debug_type_enums[type];
+      GLenum gl_severity = debug_severity_enums[severity];
+      GLDEBUGPROC callback = ctx->Debug->Callback;
+      const void *data = ctx->Debug->CallbackData;
+
+      /*
+       * When ctx->Debug->SyncOutput is GL_FALSE, the client is prepared for
+       * unsynchronous calls.  When it is GL_TRUE, we will not spawn threads.
+       * In either case, we can call the callback unlocked.
+       */
+      _mesa_unlock_debug_state(ctx);
+      callback(gl_source, gl_type, id, gl_severity, len, buf, data);
+   }
+   else {
+      debug_log_message(ctx->Debug, source, type, id, severity, len, buf);
+      _mesa_unlock_debug_state(ctx);
+   }
+}
+
+/**
+ * Log a client or driver debug message.
+ */
+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)
+{
+   struct gl_debug_state *debug = _mesa_lock_debug_state(ctx);
+
+   if (!debug)
+      return;
+
+   log_msg_locked_and_unlock(ctx, source, type, id, severity, len, buf);
+}
+
+
+/**
+ * Verify that source, type, and severity are valid enums.
+ *
+ * The 'caller' param is used for handling values available
+ * only in glDebugMessageInsert or glDebugMessageControl
+ */
+static GLboolean
+validate_params(struct gl_context *ctx, unsigned caller,
+                const char *callerstr, GLenum source, GLenum type,
+                GLenum severity)
+{
+#define INSERT 1
+#define CONTROL 2
+   switch(source) {
+   case GL_DEBUG_SOURCE_APPLICATION_ARB:
+   case GL_DEBUG_SOURCE_THIRD_PARTY_ARB:
+      break;
+   case GL_DEBUG_SOURCE_API_ARB:
+   case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB:
+   case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB:
+   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;
+   }
+
+   switch(type) {
+   case GL_DEBUG_TYPE_ERROR_ARB:
+   case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:
+   case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:
+   case GL_DEBUG_TYPE_PERFORMANCE_ARB:
+   case GL_DEBUG_TYPE_PORTABILITY_ARB:
+   case GL_DEBUG_TYPE_OTHER_ARB:
+   case GL_DEBUG_TYPE_MARKER:
+   case GL_DEBUG_TYPE_PUSH_GROUP:
+   case GL_DEBUG_TYPE_POP_GROUP:
+      break;
+   case GL_DONT_CARE:
+      if (caller == CONTROL)
+         break;
+      else
+         goto error;
+   default:
+      goto error;
+   }
+
+   switch(severity) {
+   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:
+   _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,
+                const GLchar *buf)
+{
+
+   if (length < 0) {
+      GLsizei len = strlen(buf);
+
+      if (len >= MAX_DEBUG_MESSAGE_LENGTH) {
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                    "%s(null terminated string length=%d, is not less than "
+                    "GL_MAX_DEBUG_MESSAGE_LENGTH=%d)", callerstr, len,
+                    MAX_DEBUG_MESSAGE_LENGTH);
+         return GL_FALSE;
+      }
+   }
+
+   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_DebugMessageInsert(GLenum source, GLenum type, GLuint id,
+                         GLenum severity, GLint length,
+                         const GLchar *buf)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   const char *callerstr;
+
+   if (_mesa_is_desktop_gl(ctx))
+      callerstr = "glDebugMessageInsert";
+   else
+      callerstr = "glDebugMessageInsertKHR";
+
+   if (!validate_params(ctx, INSERT, callerstr, source, type, severity))
+      return; /* GL_INVALID_ENUM */
+
+   if (!validate_length(ctx, callerstr, length, buf))
+      return; /* GL_INVALID_VALUE */
+
+   _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);
+
+   if (type == GL_DEBUG_TYPE_MARKER && ctx->Driver.EmitStringMarker) {
+      /* if length not specified, string will be null terminated: */
+      if (length < 0)
+         length = strlen(buf);
+      ctx->Driver.EmitStringMarker(ctx, buf, length);
+   }
+}
+
+
+GLuint GLAPIENTRY
+_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;
+   const char *callerstr;
+   GLuint ret;
+
+   if (_mesa_is_desktop_gl(ctx))
+      callerstr = "glGetDebugMessageLog";
+   else
+      callerstr = "glGetDebugMessageLogKHR";
+
+   if (!messageLog)
+      logSize = 0;
+
+   if (logSize < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "%s(logSize=%d : logSize must not be negative)",
+                  callerstr, logSize);
+      return 0;
+   }
+
+   debug = _mesa_lock_debug_state(ctx);
+   if (!debug)
+      return 0;
+
+   for (ret = 0; ret < count; ret++) {
+      const struct gl_debug_message *msg = debug_fetch_message(debug);
+      GLsizei len;
+
+      if (!msg)
+         break;
+
+      len = msg->length;
+      if (len < 0)
+         len = strlen(msg->message);
+
+      if (logSize < len+1 && messageLog != NULL)
+         break;
+
+      if (messageLog) {
+         assert(msg->message[len] == '\0');
+         (void) strncpy(messageLog, msg->message, (size_t)len+1);
+
+         messageLog += len+1;
+         logSize -= len+1;
+      }
+
+      if (lengths)
+         *lengths++ = len+1;
+      if (severities)
+         *severities++ = debug_severity_enums[msg->severity];
+      if (sources)
+         *sources++ = debug_source_enums[msg->source];
+      if (types)
+         *types++ = debug_type_enums[msg->type];
+      if (ids)
+         *ids++ = msg->id;
+
+      debug_delete_messages(debug, 1);
+   }
+
+   _mesa_unlock_debug_state(ctx);
+
+   return ret;
+}
+
+
+void GLAPIENTRY
+_mesa_DebugMessageControl(GLenum gl_source, GLenum gl_type,
+                          GLenum gl_severity, GLsizei count,
+                          const GLuint *ids, GLboolean enabled)
+{
+   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;
+   struct gl_debug_state *debug;
+
+   if (_mesa_is_desktop_gl(ctx))
+      callerstr = "glDebugMessageControl";
+   else
+      callerstr = "glDebugMessageControlKHR";
+
+   if (count < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "%s(count=%d : count must not be negative)", callerstr,
+                  count);
+      return;
+   }
+
+   if (!validate_params(ctx, CONTROL, callerstr, 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,
+                  "%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;
+   }
+
+   debug = _mesa_lock_debug_state(ctx);
+   if (!debug)
+      return;
+
+   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);
+   }
+
+   _mesa_unlock_debug_state(ctx);
+}
+
+
+void GLAPIENTRY
+_mesa_DebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_debug_state *debug = _mesa_lock_debug_state(ctx);
+   if (debug) {
+      debug->Callback = callback;
+      debug->CallbackData = userParam;
+      _mesa_unlock_debug_state(ctx);
+   }
+}
+
+
+void GLAPIENTRY
+_mesa_PushDebugGroup(GLenum source, GLuint id, GLsizei length,
+                     const GLchar *message)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   const char *callerstr;
+   struct gl_debug_state *debug;
+   struct gl_debug_message *emptySlot;
+
+   if (_mesa_is_desktop_gl(ctx))
+      callerstr = "glPushDebugGroup";
+   else
+      callerstr = "glPushDebugGroupKHR";
+
+   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;
+   }
+
+   if (!validate_length(ctx, callerstr, length, message))
+      return; /* GL_INVALID_VALUE */
+
+   debug = _mesa_lock_debug_state(ctx);
+   if (!debug)
+      return;
+
+   if (debug->CurrentGroup >= MAX_DEBUG_GROUP_STACK_DEPTH-1) {
+      _mesa_unlock_debug_state(ctx);
+      _mesa_error(ctx, GL_STACK_OVERFLOW, "%s", callerstr);
+      return;
+   }
+
+   /* 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);
+
+   log_msg_locked_and_unlock(ctx,
+         gl_enum_to_debug_source(source),
+         MESA_DEBUG_TYPE_PUSH_GROUP, id,
+         MESA_DEBUG_SEVERITY_NOTIFICATION, length,
+         message);
+}
+
+
+void GLAPIENTRY
+_mesa_PopDebugGroup(void)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   const char *callerstr;
+   struct gl_debug_state *debug;
+   struct gl_debug_message *gdmessage, msg;
+
+   if (_mesa_is_desktop_gl(ctx))
+      callerstr = "glPopDebugGroup";
+   else
+      callerstr = "glPopDebugGroupKHR";
+
+   debug = _mesa_lock_debug_state(ctx);
+   if (!debug)
+      return;
+
+   if (debug->CurrentGroup <= 0) {
+      _mesa_unlock_debug_state(ctx);
+      _mesa_error(ctx, GL_STACK_UNDERFLOW, "%s", callerstr);
+      return;
+   }
+
+   debug_pop_group(debug);
+
+   /* make a shallow copy */
+   gdmessage = debug_get_group_message(debug);
+   msg = *gdmessage;
+   gdmessage->message = NULL;
+   gdmessage->length = 0;
+
+   log_msg_locked_and_unlock(ctx,
+         msg.source,
+         gl_enum_to_debug_type(GL_DEBUG_TYPE_POP_GROUP),
+         msg.id,
+         gl_enum_to_debug_severity(GL_DEBUG_SEVERITY_NOTIFICATION),
+         msg.length, msg.message);
+
+   debug_message_clear(&msg);
+}
+
+
+void
+_mesa_init_debug_output(struct gl_context *ctx)
+{
+   mtx_init(&ctx->DebugMutex, mtx_plain);
+}
+
+
+void
+_mesa_free_errors_data(struct gl_context *ctx)
+{
+   if (ctx->Debug) {
+      debug_destroy(ctx->Debug);
+      /* set to NULL just in case it is used before context is completely gone. */
+      ctx->Debug = NULL;
+   }
+
+   mtx_destroy(&ctx->DebugMutex);
+}
+
+void GLAPIENTRY
+_mesa_StringMarkerGREMEDY(GLsizei len, const GLvoid *string)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (ctx->Extensions.GREMEDY_string_marker) {
+      /* if length not specified, string will be null terminated: */
+      if (len <= 0)
+         len = strlen(string);
+      ctx->Driver.EmitStringMarker(ctx, string, len);
+   } else {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "StringMarkerGREMEDY");
+   }
+}
diff --git a/src/mesa/main/debug_output.h b/src/mesa/main/debug_output.h
new file mode 100644
index 00000000000..9d8be4f2273
--- /dev/null
+++ b/src/mesa/main/debug_output.h
@@ -0,0 +1,107 @@
+/*
+ * Mesa 3-D graphics library
+ *
+ * Copyright (C) 1999-2016  Brian Paul, et al   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+
+#ifndef DEBUG_OUTPUT_H
+#define DEBUG_OUTPUT_H
+
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "compiler.h"
+#include "glheader.h"
+#include "mtypes.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+void
+_mesa_init_debug_output(struct gl_context *ctx);
+
+void
+_mesa_free_errors_data(struct gl_context *ctx);
+
+void
+_mesa_debug_get_id(GLuint *id);
+
+bool
+_mesa_set_debug_state_int(struct gl_context *ctx, GLenum pname, GLint val);
+
+GLint
+_mesa_get_debug_state_int(struct gl_context *ctx, GLenum pname);
+
+void *
+_mesa_get_debug_state_ptr(struct gl_context *ctx, GLenum pname);
+
+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);
+
+bool
+_mesa_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);
+
+void GLAPIENTRY
+_mesa_DebugMessageInsert(GLenum source, GLenum type, GLuint id,
+                         GLenum severity, GLint length,
+                         const GLchar* buf);
+
+GLuint GLAPIENTRY
+_mesa_GetDebugMessageLog(GLuint count, GLsizei logSize, GLenum* sources,
+                         GLenum* types, GLenum* ids, GLenum* severities,
+                         GLsizei* lengths, GLchar* messageLog);
+
+void GLAPIENTRY
+_mesa_DebugMessageControl(GLenum source, GLenum type, GLenum severity,
+                          GLsizei count, const GLuint *ids,
+                          GLboolean enabled);
+
+void GLAPIENTRY
+_mesa_DebugMessageCallback(GLDEBUGPROC callback,
+                           const void *userParam);
+
+void GLAPIENTRY
+_mesa_PushDebugGroup(GLenum source, GLuint id, GLsizei length,
+                     const GLchar *message);
+
+void GLAPIENTRY
+_mesa_PopDebugGroup(void);
+
+void GLAPIENTRY
+_mesa_StringMarkerGREMEDY(GLsizei len, const GLvoid *string);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* DEBUG_OUTPUT_H */
diff --git a/src/mesa/main/dlist.c b/src/mesa/main/dlist.c
index cd8e3b6a2f2..fb31d2f2706 100644
--- a/src/mesa/main/dlist.c
+++ b/src/mesa/main/dlist.c
@@ -194,7 +194,7 @@ typedef enum
    OPCODE_BLEND_FUNC_SEPARATE_I,
 
    OPCODE_CALL_LIST,
-   OPCODE_CALL_LIST_OFFSET,
+   OPCODE_CALL_LISTS,
    OPCODE_CLEAR,
    OPCODE_CLEAR_ACCUM,
    OPCODE_CLEAR_COLOR,
@@ -706,6 +706,10 @@ _mesa_delete_list(struct gl_context *ctx, struct gl_display_list *dlist)
             free(get_pointer(&n[10]));
             n += InstSize[n[0].opcode];
             break;
+         case OPCODE_CALL_LISTS:
+            free(get_pointer(&n[3]));
+            n += InstSize[n[0].opcode];
+            break;
          case OPCODE_DRAW_PIXELS:
             free(get_pointer(&n[5]));
             n += InstSize[n[0].opcode];
@@ -1569,37 +1573,49 @@ static void GLAPIENTRY
 save_CallLists(GLsizei num, GLenum type, const GLvoid * lists)
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLint i;
-   GLboolean typeErrorFlag;
+   unsigned type_size;
+   Node *n;
+   void *lists_copy;
 
    SAVE_FLUSH_VERTICES(ctx);
 
    switch (type) {
    case GL_BYTE:
    case GL_UNSIGNED_BYTE:
+      type_size = 1;
+      break;
    case GL_SHORT:
    case GL_UNSIGNED_SHORT:
+   case GL_2_BYTES:
+      type_size = 2;
+      break;
+   case GL_3_BYTES:
+      type_size = 3;
+      break;
    case GL_INT:
    case GL_UNSIGNED_INT:
    case GL_FLOAT:
-   case GL_2_BYTES:
-   case GL_3_BYTES:
    case GL_4_BYTES:
-      typeErrorFlag = GL_FALSE;
+      type_size = 4;
       break;
    default:
-      typeErrorFlag = GL_TRUE;
+      type_size = 0;
    }
 
-   for (i = 0; i < num; i++) {
-      GLint list = translate_id(i, type, lists);
-      Node *n = alloc_instruction(ctx, OPCODE_CALL_LIST_OFFSET, 2);
-      if (n) {
-         n[1].i = list;
-         n[2].b = typeErrorFlag;
-      }
+   if (num > 0 && type_size > 0) {
+      /* create a copy of the array of list IDs to save in the display list */
+      lists_copy = memdup(lists, num * type_size);
+   } else {
+      lists_copy = NULL;
    }
 
+   n = alloc_instruction(ctx, OPCODE_CALL_LISTS, 2 + POINTER_DWORDS);
+   if (n) {
+      n[1].i = num;
+      n[2].e = type;
+      save_pointer(&n[3], lists_copy);
+   };
+
    /* After this, we don't know what state we're in.  Invalidate all
     * cached information previously gathered:
     */
@@ -7772,15 +7788,9 @@ execute_list(struct gl_context *ctx, GLuint list)
                execute_list(ctx, n[1].ui);
             }
             break;
-         case OPCODE_CALL_LIST_OFFSET:
-            /* Generated by glCallLists() so we must add ListBase */
-            if (n[2].b) {
-               /* user specified a bad data type at compile time */
-               _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
-            }
-            else if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
-               GLuint list = (GLuint) (ctx->List.ListBase + n[1].i);
-               execute_list(ctx, list);
+         case OPCODE_CALL_LISTS:
+            if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
+               CALL_CallLists(ctx->Exec, (n[1].i, n[2].e, get_pointer(&n[3])));
             }
             break;
          case OPCODE_CLEAR:
@@ -9105,6 +9115,14 @@ _mesa_CallLists(GLsizei n, GLenum type, const GLvoid * lists)
       return;
    }
 
+   if (n < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glCallLists(n < 0)");
+      return;
+   } else if (n == 0 || lists == NULL) {
+      /* nothing to do */
+      return;
+   }
+
    /* Save the CompileFlag status, turn it off, execute display list,
     * and restore the CompileFlag.
     */
@@ -9728,9 +9746,8 @@ print_list(struct gl_context *ctx, GLuint list, const char *fname)
          case OPCODE_CALL_LIST:
             fprintf(f, "CallList %d\n", (int) n[1].ui);
             break;
-         case OPCODE_CALL_LIST_OFFSET:
-            fprintf(f, "CallList %d + offset %u = %u\n", (int) n[1].ui,
-                         ctx->List.ListBase, ctx->List.ListBase + n[1].ui);
+         case OPCODE_CALL_LISTS:
+            fprintf(f, "CallLists %d, %s\n", n[1].i, enum_string(n[1].e));
             break;
          case OPCODE_DISABLE:
             fprintf(f, "Disable %s\n", enum_string(n[1].e));
diff --git a/src/mesa/main/dlist.h b/src/mesa/main/dlist.h
index a1214674c62..7a23208ba5a 100644
--- a/src/mesa/main/dlist.h
+++ b/src/mesa/main/dlist.h
@@ -38,46 +38,61 @@
 
 GLboolean GLAPIENTRY
 _mesa_IsList(GLuint list);
+
 void GLAPIENTRY
 _mesa_DeleteLists(GLuint list, GLsizei range);
+
 GLuint GLAPIENTRY
 _mesa_GenLists(GLsizei range);
+
 void GLAPIENTRY
 _mesa_NewList(GLuint name, GLenum mode);
+
 void GLAPIENTRY
 _mesa_EndList(void);
+
 void GLAPIENTRY
-_mesa_CallList( GLuint list );
+_mesa_CallList(GLuint list);
+
 void GLAPIENTRY
-_mesa_CallLists( GLsizei n, GLenum type, const GLvoid *lists );
+_mesa_CallLists(GLsizei n, GLenum type, const GLvoid *lists);
+
 void GLAPIENTRY
 _mesa_ListBase(GLuint base);
 
-extern struct gl_display_list *
+struct gl_display_list *
 _mesa_lookup_list(struct gl_context *ctx, GLuint list);
 
-extern void _mesa_compile_error( struct gl_context *ctx, GLenum error, const char *s );
+void
+_mesa_compile_error(struct gl_context *ctx, GLenum error, const char *s);
 
-extern void *_mesa_dlist_alloc(struct gl_context *ctx, GLuint opcode, GLuint sz);
+void *
+_mesa_dlist_alloc(struct gl_context *ctx, GLuint opcode, GLuint sz);
 
-extern void *
+void *
 _mesa_dlist_alloc_aligned(struct gl_context *ctx, GLuint opcode, GLuint bytes);
 
-extern GLint _mesa_dlist_alloc_opcode( struct gl_context *ctx, GLuint sz,
-                                       void (*execute)( struct gl_context *, void * ),
-                                       void (*destroy)( struct gl_context *, void * ),
-                                       void (*print)( struct gl_context *, void *, FILE * ) );
+GLint
+_mesa_dlist_alloc_opcode(struct gl_context *ctx, GLuint sz,
+                         void (*execute)(struct gl_context *, void *),
+                         void (*destroy)(struct gl_context *, void *),
+                         void (*print)(struct gl_context *, void *, FILE *));
 
-extern void _mesa_delete_list(struct gl_context *ctx, struct gl_display_list *dlist);
+void
+_mesa_delete_list(struct gl_context *ctx, struct gl_display_list *dlist);
 
-extern void _mesa_initialize_save_table(const struct gl_context *);
+void
+_mesa_initialize_save_table(const struct gl_context *);
 
-extern void _mesa_install_dlist_vtxfmt(struct _glapi_table *disp,
-                                       const GLvertexformat *vfmt);
+void
+_mesa_install_dlist_vtxfmt(struct _glapi_table *disp,
+                           const GLvertexformat *vfmt);
 
-extern void _mesa_init_display_list( struct gl_context * ctx );
+void
+_mesa_init_display_list(struct gl_context * ctx);
 
-extern void _mesa_free_display_list_data(struct gl_context *ctx);
+void
+_mesa_free_display_list_data(struct gl_context *ctx);
 
 
 #endif /* DLIST_H */
diff --git a/src/mesa/main/enable.c b/src/mesa/main/enable.c
index f7941817845..3fd3c2747ea 100644
--- a/src/mesa/main/enable.c
+++ b/src/mesa/main/enable.c
@@ -31,6 +31,7 @@
 #include "glheader.h"
 #include "clip.h"
 #include "context.h"
+#include "debug_output.h"
 #include "enable.h"
 #include "errors.h"
 #include "light.h"
diff --git a/src/mesa/main/errors.c b/src/mesa/main/errors.c
index 674364c7b0c..9932b4a5a89 100644
--- a/src/mesa/main/errors.c
+++ b/src/mesa/main/errors.c
@@ -34,6 +34,7 @@
 #include "enums.h"
 #include "imports.h"
 #include "context.h"
+#include "debug_output.h"
 #include "dispatch.h"
 #include "hash.h"
 #include "mtypes.h"
@@ -41,1265 +42,6 @@
 #include "util/hash_table.h"
 #include "util/simple_list.h"
 
-static mtx_t DynamicIDMutex = _MTX_INITIALIZER_NP;
-static GLuint NextDynamicID = 1;
-
-/**
- * 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;
-   /* length as given by the user - if message was explicitly null terminated,
-    * length can be negative */
-   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 CurrentGroup; // GroupStackDepth - 1
-
-   struct gl_debug_log Log;
-};
-
-static char out_of_memory[] = "Debugging error: out of memory";
-
-static const GLenum debug_source_enums[] = {
-   GL_DEBUG_SOURCE_API,
-   GL_DEBUG_SOURCE_WINDOW_SYSTEM,
-   GL_DEBUG_SOURCE_SHADER_COMPILER,
-   GL_DEBUG_SOURCE_THIRD_PARTY,
-   GL_DEBUG_SOURCE_APPLICATION,
-   GL_DEBUG_SOURCE_OTHER,
-};
-
-static const GLenum debug_type_enums[] = {
-   GL_DEBUG_TYPE_ERROR,
-   GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR,
-   GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR,
-   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)
-{
-   unsigned i;
-
-   for (i = 0; i < ARRAY_SIZE(debug_source_enums); i++) {
-      if (debug_source_enums[i] == e)
-         break;
-   }
-   return i;
-}
-
-static enum mesa_debug_type
-gl_enum_to_debug_type(GLenum e)
-{
-   unsigned i;
-
-   for (i = 0; i < ARRAY_SIZE(debug_type_enums); i++) {
-      if (debug_type_enums[i] == e)
-         break;
-   }
-   return i;
-}
-
-static enum mesa_debug_severity
-gl_enum_to_debug_severity(GLenum e)
-{
-   unsigned i;
-
-   for (i = 0; i < ARRAY_SIZE(debug_severity_enums); i++) {
-      if (debug_severity_enums[i] == e)
-         break;
-   }
-   return i;
-}
-
-
-/**
- * Handles generating a GL_ARB_debug_output message ID generated by the GL or
- * GLSL compiler.
- *
- * The GL API has this "ID" mechanism, where the intention is to allow a
- * client to filter in/out messages based on source, type, and ID.  Of course,
- * building a giant enum list of all debug output messages that Mesa might
- * generate is ridiculous, so instead we have our caller pass us a pointer to
- * static storage where the ID should get stored.  This ID will be shared
- * across all contexts for that message (which seems like a desirable
- * property, even if it's not expected by the spec), but note that it won't be
- * the same between executions if messages aren't generated in the same order.
- */
-static void
-debug_get_id(GLuint *id)
-{
-   if (!(*id)) {
-      mtx_lock(&DynamicIDMutex);
-      if (!(*id))
-         *id = NextDynamicID++;
-      mtx_unlock(&DynamicIDMutex);
-   }
-}
-
-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)
-{
-   GLsizei length = len;
-
-   assert(!msg->message && !msg->length);
-
-   if (length < 0)
-      length = strlen(buf);
-
-   msg->message = malloc(length+1);
-   if (msg->message) {
-      (void) strncpy(msg->message, buf, (size_t)length);
-      msg->message[length] = '\0';
-
-      msg->length = len;
-      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 = -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_MEDIUM ) |
-                      (1 << MESA_DEBUG_SEVERITY_HIGH) |
-                      (1 << MESA_DEBUG_SEVERITY_NOTIFICATION);
-}
-
-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.
- */
-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;
-}
-
-/**
- * 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 void
-debug_namespace_set_all(struct gl_debug_namespace *ns,
-                        enum mesa_debug_severity severity,
-                        bool enabled)
-{
-   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);
-      }
-   }
-}
-
-/**
- * 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 = ns->DefaultState;
-   foreach(node, &ns->Elements) {
-      struct gl_debug_element *elem = (struct gl_debug_element *) node;
-
-      if (elem->ID == id) {
-         state = elem->State;
-         break;
-      }
-   }
-
-   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->CurrentGroup;
-   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->CurrentGroup;
-   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;
-         }
-      }
-   }
-
-   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->CurrentGroup;
-
-   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->CurrentGroup > 0) {
-      debug_clear_group(debug);
-      debug->CurrentGroup--;
-   }
-
-   debug_clear_group(debug);
-   free(debug);
-}
-
-/**
- * Sets the state of the given message source/type/ID tuple.
- */
-static void
-debug_set_message_enable(struct gl_debug_state *debug,
-                         enum mesa_debug_source source,
-                         enum mesa_debug_type type,
-                         GLuint id, GLboolean enabled)
-{
-   const GLint gstack = debug->CurrentGroup;
-   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->CurrentGroup;
-   int s, t, smax, tmax;
-
-   if (source == MESA_DEBUG_SOURCE_COUNT) {
-      source = 0;
-      smax = MESA_DEBUG_SOURCE_COUNT;
-   } else {
-      smax = source+1;
-   }
-
-   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->CurrentGroup;
-   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);
-}
-
-/**
- * 'buf' is not necessarily a null-terminated string. When logging, copy
- * 'len' characters from it, store them in a new, null-terminated string,
- * and remember the number of bytes used by that string, *including*
- * the null terminator this time.
- */
-static void
-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_message *emptySlot;
-
-   assert(len < MAX_DEBUG_MESSAGE_LENGTH);
-
-   if (log->NumMessages == MAX_DEBUG_LOGGED_MESSAGES)
-      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, int 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;
-   }
-}
-
-static struct gl_debug_message *
-debug_get_group_message(struct gl_debug_state *debug)
-{
-   return &debug->GroupMessages[debug->CurrentGroup];
-}
-
-static void
-debug_push_group(struct gl_debug_state *debug)
-{
-   const GLint gstack = debug->CurrentGroup;
-
-   /* just point to the previous stack */
-   debug->Groups[gstack + 1] = debug->Groups[gstack];
-   debug->CurrentGroup++;
-}
-
-static void
-debug_pop_group(struct gl_debug_state *debug)
-{
-   debug_clear_group(debug);
-   debug->CurrentGroup--;
-}
-
-
-/**
- * Lock and return debug state for the context.  The debug state will be
- * allocated and initialized upon the first call.  When NULL is returned, the
- * debug state is not locked.
- */
-static struct gl_debug_state *
-_mesa_lock_debug_state(struct gl_context *ctx)
-{
-   mtx_lock(&ctx->DebugMutex);
-
-   if (!ctx->Debug) {
-      ctx->Debug = debug_create();
-      if (!ctx->Debug) {
-         GET_CURRENT_CONTEXT(cur);
-         mtx_unlock(&ctx->DebugMutex);
-
-         /*
-          * This function may be called from other threads.  When that is the
-          * case, we cannot record this OOM error.
-          */
-         if (ctx == cur)
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "allocating debug state");
-
-         return NULL;
-      }
-   }
-
-   return ctx->Debug;
-}
-
-static void
-_mesa_unlock_debug_state(struct gl_context *ctx)
-{
-   mtx_unlock(&ctx->DebugMutex);
-}
-
-/**
- * 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_lock_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;
-   }
-
-   _mesa_unlock_debug_state(ctx);
-
-   return true;
-}
-
-/**
- * Query the integer debug state specified by \p pname.  This can be called
- * _mesa_GetIntegerv for example.
- */
-GLint
-_mesa_get_debug_state_int(struct gl_context *ctx, GLenum pname)
-{
-   struct gl_debug_state *debug;
-   GLint val;
-
-   mtx_lock(&ctx->DebugMutex);
-   debug = ctx->Debug;
-   if (!debug) {
-      mtx_unlock(&ctx->DebugMutex);
-      return 0;
-   }
-
-   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->CurrentGroup + 1;
-      break;
-   default:
-      assert(!"unknown debug output param");
-      val = 0;
-      break;
-   }
-
-   mtx_unlock(&ctx->DebugMutex);
-
-   return val;
-}
-
-/**
- * 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;
-
-   mtx_lock(&ctx->DebugMutex);
-   debug = ctx->Debug;
-   if (!debug) {
-      mtx_unlock(&ctx->DebugMutex);
-      return NULL;
-   }
-
-   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;
-   }
-
-   mtx_unlock(&ctx->DebugMutex);
-
-   return val;
-}
-
-/**
- * Insert a debug message.  The mutex is assumed to be locked, and will be
- * unlocked by this call.
- */
-static void
-log_msg_locked_and_unlock(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 = ctx->Debug;
-
-   if (!debug_is_message_enabled(debug, source, type, id, severity)) {
-      _mesa_unlock_debug_state(ctx);
-      return;
-   }
-
-   if (ctx->Debug->Callback) {
-      GLenum gl_source = debug_source_enums[source];
-      GLenum gl_type = debug_type_enums[type];
-      GLenum gl_severity = debug_severity_enums[severity];
-      GLDEBUGPROC callback = ctx->Debug->Callback;
-      const void *data = ctx->Debug->CallbackData;
-
-      /*
-       * When ctx->Debug->SyncOutput is GL_FALSE, the client is prepared for
-       * unsynchronous calls.  When it is GL_TRUE, we will not spawn threads.
-       * In either case, we can call the callback unlocked.
-       */
-      _mesa_unlock_debug_state(ctx);
-      callback(gl_source, gl_type, id, gl_severity, len, buf, data);
-   }
-   else {
-      debug_log_message(ctx->Debug, source, type, id, severity, len, buf);
-      _mesa_unlock_debug_state(ctx);
-   }
-}
-
-/**
- * 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_lock_debug_state(ctx);
-
-   if (!debug)
-      return;
-
-   log_msg_locked_and_unlock(ctx, source, type, id, severity, len, buf);
-}
-
-
-/**
- * Verify that source, type, and severity are valid enums.
- *
- * The 'caller' param is used for handling values available
- * only in glDebugMessageInsert or glDebugMessageControl
- */
-static GLboolean
-validate_params(struct gl_context *ctx, unsigned caller,
-                const char *callerstr, GLenum source, GLenum type,
-                GLenum severity)
-{
-#define INSERT 1
-#define CONTROL 2
-   switch(source) {
-   case GL_DEBUG_SOURCE_APPLICATION_ARB:
-   case GL_DEBUG_SOURCE_THIRD_PARTY_ARB:
-      break;
-   case GL_DEBUG_SOURCE_API_ARB:
-   case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB:
-   case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB:
-   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;
-   }
-
-   switch(type) {
-   case GL_DEBUG_TYPE_ERROR_ARB:
-   case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:
-   case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:
-   case GL_DEBUG_TYPE_PERFORMANCE_ARB:
-   case GL_DEBUG_TYPE_PORTABILITY_ARB:
-   case GL_DEBUG_TYPE_OTHER_ARB:
-   case GL_DEBUG_TYPE_MARKER:
-   case GL_DEBUG_TYPE_PUSH_GROUP:
-   case GL_DEBUG_TYPE_POP_GROUP:
-      break;
-   case GL_DONT_CARE:
-      if (caller == CONTROL)
-         break;
-      else
-         goto error;
-   default:
-      goto error;
-   }
-
-   switch(severity) {
-   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:
-   _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,
-                const GLchar *buf)
-{
-
-   if (length < 0) {
-      GLsizei len = strlen(buf);
-
-      if (len >= MAX_DEBUG_MESSAGE_LENGTH) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                    "%s(null terminated string length=%d, is not less than "
-                    "GL_MAX_DEBUG_MESSAGE_LENGTH=%d)", callerstr, len,
-                    MAX_DEBUG_MESSAGE_LENGTH);
-         return GL_FALSE;
-      }
-   }
-
-   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_DebugMessageInsert(GLenum source, GLenum type, GLuint id,
-                         GLenum severity, GLint length,
-                         const GLchar *buf)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const char *callerstr;
-
-   if (_mesa_is_desktop_gl(ctx))
-      callerstr = "glDebugMessageInsert";
-   else
-      callerstr = "glDebugMessageInsertKHR";
-
-   if (!validate_params(ctx, INSERT, callerstr, source, type, severity))
-      return; /* GL_INVALID_ENUM */
-
-   if (!validate_length(ctx, callerstr, length, buf))
-      return; /* GL_INVALID_VALUE */
-
-   log_msg(ctx, gl_enum_to_debug_source(source),
-           gl_enum_to_debug_type(type), id,
-           gl_enum_to_debug_severity(severity),
-           length, buf);
-
-   if (type == GL_DEBUG_TYPE_MARKER && ctx->Driver.EmitStringMarker) {
-      /* if length not specified, string will be null terminated: */
-      if (length < 0)
-         length = strlen(buf);
-      ctx->Driver.EmitStringMarker(ctx, buf, length);
-   }
-}
-
-
-GLuint GLAPIENTRY
-_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;
-   const char *callerstr;
-   GLuint ret;
-
-   if (_mesa_is_desktop_gl(ctx))
-      callerstr = "glGetDebugMessageLog";
-   else
-      callerstr = "glGetDebugMessageLogKHR";
-
-   if (!messageLog)
-      logSize = 0;
-
-   if (logSize < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "%s(logSize=%d : logSize must not be negative)",
-                  callerstr, logSize);
-      return 0;
-   }
-
-   debug = _mesa_lock_debug_state(ctx);
-   if (!debug)
-      return 0;
-
-   for (ret = 0; ret < count; ret++) {
-      const struct gl_debug_message *msg = debug_fetch_message(debug);
-      GLsizei len;
-
-      if (!msg)
-         break;
-
-      len = msg->length;
-      if (len < 0)
-         len = strlen(msg->message);
-
-      if (logSize < len+1 && messageLog != NULL)
-         break;
-
-      if (messageLog) {
-         assert(msg->message[len] == '\0');
-         (void) strncpy(messageLog, msg->message, (size_t)len+1);
-
-         messageLog += len+1;
-         logSize -= len+1;
-      }
-
-      if (lengths)
-         *lengths++ = len+1;
-      if (severities)
-         *severities++ = debug_severity_enums[msg->severity];
-      if (sources)
-         *sources++ = debug_source_enums[msg->source];
-      if (types)
-         *types++ = debug_type_enums[msg->type];
-      if (ids)
-         *ids++ = msg->id;
-
-      debug_delete_messages(debug, 1);
-   }
-
-   _mesa_unlock_debug_state(ctx);
-
-   return ret;
-}
-
-
-void GLAPIENTRY
-_mesa_DebugMessageControl(GLenum gl_source, GLenum gl_type,
-                          GLenum gl_severity, GLsizei count,
-                          const GLuint *ids, GLboolean enabled)
-{
-   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;
-   struct gl_debug_state *debug;
-
-   if (_mesa_is_desktop_gl(ctx))
-      callerstr = "glDebugMessageControl";
-   else
-      callerstr = "glDebugMessageControlKHR";
-
-   if (count < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "%s(count=%d : count must not be negative)", callerstr,
-                  count);
-      return;
-   }
-
-   if (!validate_params(ctx, CONTROL, callerstr, 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,
-                  "%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;
-   }
-
-   debug = _mesa_lock_debug_state(ctx);
-   if (!debug)
-      return;
-
-   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);
-   }
-
-   _mesa_unlock_debug_state(ctx);
-}
-
-
-void GLAPIENTRY
-_mesa_DebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_debug_state *debug = _mesa_lock_debug_state(ctx);
-   if (debug) {
-      debug->Callback = callback;
-      debug->CallbackData = userParam;
-      _mesa_unlock_debug_state(ctx);
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_PushDebugGroup(GLenum source, GLuint id, GLsizei length,
-                     const GLchar *message)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const char *callerstr;
-   struct gl_debug_state *debug;
-   struct gl_debug_message *emptySlot;
-
-   if (_mesa_is_desktop_gl(ctx))
-      callerstr = "glPushDebugGroup";
-   else
-      callerstr = "glPushDebugGroupKHR";
-
-   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;
-   }
-
-   if (!validate_length(ctx, callerstr, length, message))
-      return; /* GL_INVALID_VALUE */
-
-   debug = _mesa_lock_debug_state(ctx);
-   if (!debug)
-      return;
-
-   if (debug->CurrentGroup >= MAX_DEBUG_GROUP_STACK_DEPTH-1) {
-      _mesa_unlock_debug_state(ctx);
-      _mesa_error(ctx, GL_STACK_OVERFLOW, "%s", callerstr);
-      return;
-   }
-
-   /* 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);
-
-   log_msg_locked_and_unlock(ctx,
-         gl_enum_to_debug_source(source),
-         MESA_DEBUG_TYPE_PUSH_GROUP, id,
-         MESA_DEBUG_SEVERITY_NOTIFICATION, length,
-         message);
-}
-
-
-void GLAPIENTRY
-_mesa_PopDebugGroup(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const char *callerstr;
-   struct gl_debug_state *debug;
-   struct gl_debug_message *gdmessage, msg;
-
-   if (_mesa_is_desktop_gl(ctx))
-      callerstr = "glPopDebugGroup";
-   else
-      callerstr = "glPopDebugGroupKHR";
-
-   debug = _mesa_lock_debug_state(ctx);
-   if (!debug)
-      return;
-
-   if (debug->CurrentGroup <= 0) {
-      _mesa_unlock_debug_state(ctx);
-      _mesa_error(ctx, GL_STACK_UNDERFLOW, "%s", callerstr);
-      return;
-   }
-
-   debug_pop_group(debug);
-
-   /* make a shallow copy */
-   gdmessage = debug_get_group_message(debug);
-   msg = *gdmessage;
-   gdmessage->message = NULL;
-   gdmessage->length = 0;
-
-   log_msg_locked_and_unlock(ctx,
-         msg.source,
-         gl_enum_to_debug_type(GL_DEBUG_TYPE_POP_GROUP),
-         msg.id,
-         gl_enum_to_debug_severity(GL_DEBUG_SEVERITY_NOTIFICATION),
-         msg.length, msg.message);
-
-   debug_message_clear(&msg);
-}
-
-
-void
-_mesa_init_errors(struct gl_context *ctx)
-{
-   mtx_init(&ctx->DebugMutex, mtx_plain);
-}
-
-
-void
-_mesa_free_errors_data(struct gl_context *ctx)
-{
-   if (ctx->Debug) {
-      debug_destroy(ctx->Debug);
-      /* set to NULL just in case it is used before context is completely gone. */
-      ctx->Debug = NULL;
-   }
-
-   mtx_destroy(&ctx->DebugMutex);
-}
-
-void GLAPIENTRY
-_mesa_StringMarkerGREMEDY(GLsizei len, const GLvoid *string)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (ctx->Extensions.GREMEDY_string_marker) {
-      /* if length not specified, string will be null terminated: */
-      if (len <= 0)
-         len = strlen(string);
-      ctx->Driver.EmitStringMarker(ctx, string, len);
-   } else {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "StringMarkerGREMEDY");
-   }
-}
-
-/**********************************************************************/
-/** \name Diagnostics */
-/*@{*/
 
 static FILE *LogFile = NULL;
 
@@ -1492,11 +234,11 @@ _mesa_gl_vdebug(struct gl_context *ctx,
    char s[MAX_DEBUG_MESSAGE_LENGTH];
    int len;
 
-   debug_get_id(id);
+   _mesa_debug_get_id(id);
 
    len = _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);
 
-   log_msg(ctx, source, type, *id, severity, len, s);
+   _mesa_log_msg(ctx, source, type, *id, severity, len, s);
 }
 
 
@@ -1536,17 +278,17 @@ _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... )
     */
    static GLuint error_msg_id = 0;
 
-   debug_get_id(&error_msg_id);
+   _mesa_debug_get_id(&error_msg_id);
 
    do_output = should_output(ctx, error, fmtString);
 
    mtx_lock(&ctx->DebugMutex);
    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);
+      do_log = _mesa_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;
@@ -1585,8 +327,8 @@ _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... )
 
       /* Log the error via ARB_debug_output if needed.*/
       if (do_log) {
-         log_msg(ctx, MESA_DEBUG_SOURCE_API, MESA_DEBUG_TYPE_ERROR,
-                 error_msg_id, MESA_DEBUG_SEVERITY_HIGH, len, s2);
+         _mesa_log_msg(ctx, MESA_DEBUG_SOURCE_API, MESA_DEBUG_TYPE_ERROR,
+                       error_msg_id, MESA_DEBUG_SEVERITY_HIGH, len, s2);
       }
    }
 
@@ -1652,7 +394,7 @@ _mesa_shader_debug(struct gl_context *ctx, GLenum type, GLuint *id,
    enum mesa_debug_severity severity = MESA_DEBUG_SEVERITY_HIGH;
    int len;
 
-   debug_get_id(id);
+   _mesa_debug_get_id(id);
 
    len = strlen(msg);
 
@@ -1660,7 +402,5 @@ _mesa_shader_debug(struct gl_context *ctx, GLenum type, GLuint *id,
    if (len >= MAX_DEBUG_MESSAGE_LENGTH)
       len = MAX_DEBUG_MESSAGE_LENGTH - 1;
 
-   log_msg(ctx, source, type, *id, severity, len, msg);
+   _mesa_log_msg(ctx, source, type, *id, severity, len, msg);
 }
-
-/*@}*/
diff --git a/src/mesa/main/errors.h b/src/mesa/main/errors.h
index 92df2ac868a..5ad5254ff1b 100644
--- a/src/mesa/main/errors.h
+++ b/src/mesa/main/errors.h
@@ -47,14 +47,6 @@
 extern "C" {
 #endif
 
-struct _glapi_table;
-
-extern void
-_mesa_init_errors( struct gl_context *ctx );
-
-extern void
-_mesa_free_errors_data( struct gl_context *ctx );
-
 extern void
 _mesa_warning( struct gl_context *gc, const char *fmtString, ... ) PRINTFLIKE(2, 3);
 
@@ -76,6 +68,10 @@ _mesa_log(const char *fmtString, ...) PRINTFLIKE(1, 2);
 extern FILE *
 _mesa_get_log_file(void);
 
+void
+_mesa_shader_debug(struct gl_context *ctx, GLenum type, GLuint *id,
+                   const char *msg);
+
 extern void
 _mesa_gl_vdebug(struct gl_context *ctx,
                 GLuint *id,
@@ -104,42 +100,6 @@ _mesa_gl_debug(struct gl_context *ctx,
    }                                                                      \
 } while (0)
 
-bool
-_mesa_set_debug_state_int(struct gl_context *ctx, GLenum pname, GLint val);
-
-GLint
-_mesa_get_debug_state_int(struct gl_context *ctx, GLenum pname);
-
-void *
-_mesa_get_debug_state_ptr(struct gl_context *ctx, GLenum pname);
-
-extern void
-_mesa_shader_debug(struct gl_context *ctx, GLenum type, GLuint *id,
-                   const char *msg);
-
-void GLAPIENTRY
-_mesa_DebugMessageInsert(GLenum source, GLenum type, GLuint id,
-                         GLenum severity, GLint length,
-                         const GLchar* buf);
-GLuint GLAPIENTRY
-_mesa_GetDebugMessageLog(GLuint count, GLsizei logSize, GLenum* sources,
-                         GLenum* types, GLenum* ids, GLenum* severities,
-                         GLsizei* lengths, GLchar* messageLog);
-void GLAPIENTRY
-_mesa_DebugMessageControl(GLenum source, GLenum type, GLenum severity,
-                          GLsizei count, const GLuint *ids,
-                          GLboolean enabled);
-void GLAPIENTRY
-_mesa_DebugMessageCallback(GLDEBUGPROC callback,
-                           const void *userParam);
-void GLAPIENTRY
-_mesa_PushDebugGroup(GLenum source, GLuint id, GLsizei length,
-                     const GLchar *message);
-void GLAPIENTRY
-_mesa_PopDebugGroup(void);
-
-void GLAPIENTRY
-_mesa_StringMarkerGREMEDY(GLsizei len, const GLvoid *string);
 
 #ifdef __cplusplus
 }
diff --git a/src/mesa/main/extensions_table.h b/src/mesa/main/extensions_table.h
index ded6f2c06dc..d1e3a99fdc0 100644
--- a/src/mesa/main/extensions_table.h
+++ b/src/mesa/main/extensions_table.h
@@ -273,6 +273,8 @@ EXT(MESA_texture_signed_rgba                , EXT_texture_snorm
 EXT(MESA_window_pos                         , dummy_true                             , GLL,  x ,  x ,  x , 2000)
 EXT(MESA_ycbcr_texture                      , MESA_ycbcr_texture                     , GLL, GLC,  x ,  x , 2002)
 
+EXT(NVX_gpu_memory_info                     , NVX_gpu_memory_info                    , GLL, GLC,  x ,  x , 2013)
+
 EXT(NV_blend_square                         , dummy_true                             , GLL,  x ,  x ,  x , 1999)
 EXT(NV_conditional_render                   , NV_conditional_render                  , GLL, GLC,  x ,  x , 2008)
 EXT(NV_depth_clamp                          , ARB_depth_clamp                        , GLL, GLC,  x ,  x , 2001)
@@ -293,7 +295,6 @@ EXT(NV_texture_barrier                      , NV_texture_barrier
 EXT(NV_texture_env_combine4                 , NV_texture_env_combine4                , GLL,  x ,  x ,  x , 1999)
 EXT(NV_texture_rectangle                    , NV_texture_rectangle                   , GLL,  x ,  x ,  x , 2000)
 EXT(NV_vdpau_interop                        , NV_vdpau_interop                       , GLL, GLC,  x ,  x , 2010)
-EXT(NVX_gpu_memory_info                     , NVX_gpu_memory_info                    , GLL, GLC,  x ,  x , 2013)
 
 EXT(OES_EGL_image                           , OES_EGL_image                          , GLL, GLC, ES1, ES2, 2006) /* FIXME: Mesa expects GL_OES_EGL_image to be available in OpenGL contexts. */
 EXT(OES_EGL_image_external                  , OES_EGL_image_external                 ,  x ,  x , ES1, ES2, 2010)
diff --git a/src/mesa/main/get.c b/src/mesa/main/get.c
index 8453a922549..9005dc5897d 100644
--- a/src/mesa/main/get.c
+++ b/src/mesa/main/get.c
@@ -26,6 +26,7 @@
 #include "glheader.h"
 #include "context.h"
 #include "blend.h"
+#include "debug_output.h"
 #include "enable.h"
 #include "enums.h"
 #include "errors.h"
diff --git a/src/mesa/main/getstring.c b/src/mesa/main/getstring.c
index 87c5a3a194f..92f8a389cd9 100644
--- a/src/mesa/main/getstring.c
+++ b/src/mesa/main/getstring.c
@@ -26,6 +26,7 @@
 #include <stdbool.h>
 #include "glheader.h"
 #include "context.h"
+#include "debug_output.h"
 #include "get.h"
 #include "enums.h"
 #include "extensions.h"
diff --git a/src/mesa/main/queryobj.c b/src/mesa/main/queryobj.c
index b86692a5f7e..7a70b592c47 100644
--- a/src/mesa/main/queryobj.c
+++ b/src/mesa/main/queryobj.c
@@ -807,11 +807,6 @@ invalid_enum:
       return;
    }
 
-   /* TODO: Have the driver be required to handle this fixup. */
-   if (q->Target == GL_ANY_SAMPLES_PASSED ||
-       q->Target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE)
-      value = !!value;
-
    switch (ptype) {
    case GL_INT: {
       GLint *param = (GLint *)offset;
diff --git a/src/mesa/main/viewport.c b/src/mesa/main/viewport.c
index 7d8914291c3..681e46bfcf7 100644
--- a/src/mesa/main/viewport.c
+++ b/src/mesa/main/viewport.c
@@ -456,11 +456,11 @@ _mesa_get_viewport_xform(struct gl_context *ctx, unsigned i,
    translate[0] = half_width + x;
    if (ctx->Transform.ClipOrigin == GL_UPPER_LEFT) {
       scale[1] = -half_height;
-      translate[1] = half_height - y;
    } else {
       scale[1] = half_height;
-      translate[1] = half_height + y;
    }
+   translate[1] = half_height + y;
+
    if (ctx->Transform.ClipDepthMode == GL_NEGATIVE_ONE_TO_ONE) {
       scale[2] = 0.5 * (f - n);
       translate[2] = 0.5 * (n + f);