#include "mtypes.h"
#include "version.h"
#include "hash_table.h"
-#include "glapi/glthread.h"
-#define MESSAGE_LOG 1
-#define MESSAGE_LOG_ARB 2
-
-_glthread_DECLARE_STATIC_MUTEX(DynamicIDMutex);
+static mtx_t DynamicIDMutex = _MTX_INITIALIZER_NP;
static GLuint NextDynamicID = 1;
struct gl_debug_severity
GLuint ID;
};
+/**
+ * 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_msg
+{
+ enum mesa_debug_source source;
+ enum mesa_debug_type type;
+ GLuint id;
+ enum mesa_debug_severity severity;
+ GLsizei length;
+ GLcharARB *message;
+};
+
+struct gl_debug_namespace
+{
+ struct _mesa_HashTable *IDs;
+ unsigned ZeroID; /* a HashTable won't take zero, so store its state here */
+ /** lists of IDs in the hash table at each severity */
+ struct simple_node Severity[MESA_DEBUG_SEVERITY_COUNT];
+};
+
+struct gl_debug_state
+{
+ GLDEBUGPROC Callback;
+ const void *CallbackData;
+ GLboolean SyncOutput;
+ GLboolean DebugOutput;
+ GLboolean Defaults[MAX_DEBUG_GROUP_STACK_DEPTH][MESA_DEBUG_SEVERITY_COUNT][MESA_DEBUG_SOURCE_COUNT][MESA_DEBUG_TYPE_COUNT];
+ struct gl_debug_namespace Namespaces[MAX_DEBUG_GROUP_STACK_DEPTH][MESA_DEBUG_SOURCE_COUNT][MESA_DEBUG_TYPE_COUNT];
+ struct gl_debug_msg Log[MAX_DEBUG_LOGGED_MESSAGES];
+ struct gl_debug_msg DebugGroupMsgs[MAX_DEBUG_GROUP_STACK_DEPTH];
+ GLint GroupStackDepth;
+ GLint NumMessages;
+ GLint NextMsg;
+ GLint NextMsgLength; /* redundant, but copied here from Log[NextMsg].length
+ for the sake of the offsetof() code in get.c */
+};
+
static char out_of_memory[] = "Debugging error: out of memory";
static const GLenum debug_source_enums[] = {
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);
}
}
ENABLED = ENABLED_BIT | FOUND_BIT
};
-
-/**
- * Return debug state for the context. The debug state will be allocated
- * and initialized upon the first call.
- */
-struct gl_debug_state *
-_mesa_get_debug_state(struct gl_context *ctx)
+static void
+debug_message_clear(struct gl_debug_msg *msg)
{
- if (!ctx->Debug) {
- ctx->Debug = CALLOC_STRUCT(gl_debug_state);
- if (!ctx->Debug) {
- _mesa_error(ctx, GL_OUT_OF_MEMORY, "allocating debug state");
- }
- else {
- struct gl_debug_state *debug = ctx->Debug;
- int s, t, sev;
-
- /* Enable all the messages with severity HIGH or MEDIUM by default. */
- memset(debug->Defaults[0][MESA_DEBUG_SEVERITY_HIGH], GL_TRUE,
- sizeof debug->Defaults[0][MESA_DEBUG_SEVERITY_HIGH]);
- memset(debug->Defaults[0][MESA_DEBUG_SEVERITY_MEDIUM], GL_TRUE,
- sizeof debug->Defaults[0][MESA_DEBUG_SEVERITY_MEDIUM]);
- memset(debug->Defaults[0][MESA_DEBUG_SEVERITY_LOW], GL_FALSE,
- sizeof debug->Defaults[0][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++) {
- debug->Namespaces[0][s][t].IDs = _mesa_NewHashTable();
- assert(debug->Namespaces[0][s][t].IDs);
-
- for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) {
- make_empty_list(&debug->Namespaces[0][s][t].Severity[sev]);
- }
- }
- }
- }
- }
-
- return ctx->Debug;
+ if (msg->message != (char*)out_of_memory)
+ free(msg->message);
+ msg->message = NULL;
+ msg->length = 0;
}
+static void
+debug_message_store(struct gl_debug_msg *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;
+ }
+}
/**
- * Returns the state of the given message source/type/ID tuple.
+ * Allocate and initialize context debug state.
*/
-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 struct gl_debug_state *
+debug_create(void)
{
struct gl_debug_state *debug;
- uintptr_t state = 0;
-
- if (!ctx->Debug) {
- /* no debug state set so far */
- return GL_FALSE;
- }
+ int s, t, sev;
- debug = _mesa_get_debug_state(ctx);
- if (debug) {
- const GLint gstack = debug->GroupStackDepth;
- struct gl_debug_namespace *nspace =
- &debug->Namespaces[gstack][source][type];
+ debug = CALLOC_STRUCT(gl_debug_state);
+ if (!debug)
+ return NULL;
- if (!debug->DebugOutput)
- return GL_FALSE;
+ /* Enable all the messages with severity HIGH or MEDIUM by default. */
+ memset(debug->Defaults[0][MESA_DEBUG_SEVERITY_HIGH], GL_TRUE,
+ sizeof debug->Defaults[0][MESA_DEBUG_SEVERITY_HIGH]);
+ memset(debug->Defaults[0][MESA_DEBUG_SEVERITY_MEDIUM], GL_TRUE,
+ sizeof debug->Defaults[0][MESA_DEBUG_SEVERITY_MEDIUM]);
+ memset(debug->Defaults[0][MESA_DEBUG_SEVERITY_LOW], GL_FALSE,
+ sizeof debug->Defaults[0][MESA_DEBUG_SEVERITY_LOW]);
- /* 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;
+ /* 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->Namespaces[0][s][t].IDs = _mesa_NewHashTable();
+ assert(debug->Namespaces[0][s][t].IDs);
- /* 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 (debug->Defaults[gstack][severity][source][type])
- state = ENABLED;
- else
- state = DISABLED;
+ for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) {
+ make_empty_list(&debug->Namespaces[0][s][t].Severity[sev]);
}
+ }
+ }
+
+ return debug;
+}
+
+static void
+debug_clear_group_cb(GLuint key, void *data, void *userData)
+{
+}
- entry = malloc(sizeof *entry);
- if (!entry)
- goto out;
+/**
+ * Free debug state for the given stack depth.
+ */
+static void
+debug_clear_group(struct gl_debug_state *debug, GLint gstack)
+{
+ enum mesa_debug_type t;
+ enum mesa_debug_source s;
+ enum mesa_debug_severity sev;
- state |= KNOWN_SEVERITY;
+ /* 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++) {
+ struct gl_debug_namespace *nspace = &debug->Namespaces[gstack][s][t];
- if (id)
- _mesa_HashInsert(nspace->IDs, id, (void*)state);
- else
- nspace->ZeroID = state;
+ _mesa_HashDeleteAll(nspace->IDs, debug_clear_group_cb, NULL);
+ _mesa_DeleteHashTable(nspace->IDs);
+ for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) {
+ struct simple_node *node, *tmp;
+ struct gl_debug_severity *entry;
- entry->ID = id;
- insert_at_tail(&nspace->Severity[severity], &entry->link);
+ foreach_s(node, tmp, &nspace->Severity[sev]) {
+ entry = (struct gl_debug_severity *)node;
+ free(entry);
+ }
+ }
}
}
-out:
- return !!(state & ENABLED_BIT);
}
-
/**
- * Sets the state of the given message source/type/ID tuple.
+ * Loop through debug group stack tearing down states for
+ * filtering debug messages. Then free debug output state.
*/
static void
-set_message_state(struct gl_context *ctx,
- enum mesa_debug_source source,
- enum mesa_debug_type type,
- GLuint id, GLboolean enabled)
+debug_destroy(struct gl_debug_state *debug)
{
- struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
+ GLint i;
- if (debug) {
- GLint gstack = debug->GroupStackDepth;
- struct gl_debug_namespace *nspace =
- &debug->Namespaces[gstack][source][type];
- uintptr_t state;
+ for (i = 0; i <= debug->GroupStackDepth; i++)
+ debug_clear_group(debug, i);
- /* 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;
+ free(debug);
+}
- if (state == NOT_FOUND)
- state = enabled ? ENABLED : DISABLED;
- else {
- if (enabled)
- state |= ENABLED_BIT;
- else
- state &= ~ENABLED_BIT;
- }
+/**
+ * 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)
+{
+ GLint gstack = debug->GroupStackDepth;
+ struct gl_debug_namespace *nspace =
+ &debug->Namespaces[gstack][source][type];
+ uintptr_t state;
- if (id)
- _mesa_HashInsert(nspace->IDs, id, (void*)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
- nspace->ZeroID = state;
+ state &= ~ENABLED_BIT;
}
-}
+ if (id)
+ _mesa_HashInsert(nspace->IDs, id, (void*)state);
+ else
+ nspace->ZeroID = state;
+}
+/*
+ * 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
-store_message_details(struct gl_debug_msg *emptySlot,
- enum mesa_debug_source source,
- enum mesa_debug_type type, GLuint id,
- enum mesa_debug_severity severity, GLint len,
- const char *buf)
+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)
{
- assert(!emptySlot->message && !emptySlot->length);
-
- emptySlot->message = malloc(len+1);
- if (emptySlot->message) {
- (void) strncpy(emptySlot->message, buf, (size_t)len);
- emptySlot->message[len] = '\0';
-
- emptySlot->length = len+1;
- emptySlot->source = source;
- emptySlot->type = type;
- emptySlot->id = id;
- emptySlot->severity = severity;
+ const GLint gstack = debug->GroupStackDepth;
+ int s, t, sev, smax, tmax, sevmax;
+
+ if (source == MESA_DEBUG_SOURCE_COUNT) {
+ source = 0;
+ smax = MESA_DEBUG_SOURCE_COUNT;
} else {
- static GLuint oom_msg_id = 0;
- debug_get_id(&oom_msg_id);
+ smax = source+1;
+ }
- /* 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;
+ if (type == MESA_DEBUG_TYPE_COUNT) {
+ type = 0;
+ tmax = MESA_DEBUG_TYPE_COUNT;
+ } else {
+ tmax = type+1;
}
-}
+ if (severity == MESA_DEBUG_SEVERITY_COUNT) {
+ severity = 0;
+ sevmax = MESA_DEBUG_SEVERITY_COUNT;
+ } else {
+ sevmax = severity+1;
+ }
-/**
- * Remap any type exclusive to KHR_debug to something suitable
- * for ARB_debug_output
- */
-inline static int
-remap_type(GLenum type) {
+ 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;
- switch(type) {
- case GL_DEBUG_TYPE_MARKER:
- case GL_DEBUG_TYPE_PUSH_GROUP:
- case GL_DEBUG_TYPE_POP_GROUP:
- type = GL_DEBUG_TYPE_OTHER;
- default:
- ;
- }
+ /* change the default for IDs we've never seen before. */
+ debug->Defaults[gstack][sev][s][t] = enabled;
- return type;
+ /* Now change the state of IDs we *have* seen... */
+ foreach(node, &debug->Namespaces[gstack][s][t].Severity[sev]) {
+ entry = (struct gl_debug_severity *)node;
+ debug_set_message_enable(debug, s, t, entry->ID, enabled);
+ }
+ }
+ }
+ }
}
-
/**
- * Remap severity exclusive to KHR_debug to something suitable
- * for ARB_debug_output
+ * Returns if the given message source/type/ID tuple is enabled.
*/
-inline static int
-remap_severity(GLenum severity) {
+static bool
+debug_is_message_enabled(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_namespace *nspace =
+ &debug->Namespaces[gstack][source][type];
+ uintptr_t state = 0;
- if (GL_DEBUG_SEVERITY_NOTIFICATION == severity)
- severity = GL_DEBUG_SEVERITY_LOW;
+ if (!debug->DebugOutput)
+ return false;
- return severity;
-}
+ /* 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 (debug->Defaults[gstack][severity][source][type])
+ state = ENABLED;
+ else
+ state = DISABLED;
+ }
+
+ entry = malloc(sizeof *entry);
+ if (!entry)
+ goto out;
+
+ state |= KNOWN_SEVERITY;
+
+ if (id)
+ _mesa_HashInsert(nspace->IDs, id, (void*)state);
+ else
+ nspace->ZeroID = state;
+ entry->ID = id;
+ insert_at_tail(&nspace->Severity[severity], &entry->link);
+ }
+out:
+ return (state & ENABLED_BIT);
+}
/**
* 'buf' is not necessarily a null-terminated string. When logging, copy
* the null terminator this time.
*/
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)
+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_state *debug = _mesa_get_debug_state(ctx);
GLint nextEmpty;
struct gl_debug_msg *emptySlot;
- if (!debug)
- return;
-
assert(len >= 0 && len < MAX_DEBUG_MESSAGE_LENGTH);
- if (!should_log(ctx, source, type, id, severity))
- return;
-
- if (debug->Callback) {
- GLenum gl_type = debug_type_enums[type];
- GLenum gl_severity = debug_severity_enums[severity];
-
- if (debug->ARBCallback) {
- gl_severity = remap_severity(gl_severity);
- gl_type = remap_type(gl_type);
- }
- debug->Callback(debug_source_enums[source], gl_type, id, gl_severity,
- len, buf, debug->CallbackData);
- return;
- }
-
if (debug->NumMessages == MAX_DEBUG_LOGGED_MESSAGES)
return;
% MAX_DEBUG_LOGGED_MESSAGES;
emptySlot = &debug->Log[nextEmpty];
- store_message_details(emptySlot, source, type, id, severity, len, buf);
+ debug_message_store(emptySlot, source, type,
+ id, severity, len, buf);
if (debug->NumMessages == 0)
debug->NextMsgLength = debug->Log[debug->NextMsg].length;
debug->NumMessages++;
}
+/**
+ * Return the oldest debug message out of the log.
+ */
+static const struct gl_debug_msg *
+debug_fetch_message(const struct gl_debug_state *debug)
+{
+ return (debug->NumMessages) ? &debug->Log[debug->NextMsg] : NULL;
+}
/**
- * 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.
+ * Delete the oldest debug messages out of the log.
*/
-static GLsizei
-get_msg(struct gl_context *ctx, GLenum *source, GLenum *type,
- GLuint *id, GLenum *severity, GLsizei bufSize, char *buf,
- unsigned caller)
+static void
+debug_delete_messages(struct gl_debug_state *debug, unsigned count)
{
- struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
- struct gl_debug_msg *msg;
- GLsizei length;
+ if (count > debug->NumMessages)
+ count = debug->NumMessages;
- if (!debug || debug->NumMessages == 0)
- return 0;
+ while (count--) {
+ struct gl_debug_msg *msg = &debug->Log[debug->NextMsg];
- msg = &debug->Log[debug->NextMsg];
- length = msg->length;
+ assert(msg->length > 0 && msg->length == debug->NextMsgLength);
+ debug_message_clear(msg);
- assert(length > 0 && length == debug->NextMsgLength);
+ debug->NumMessages--;
+ debug->NextMsg++;
+ debug->NextMsg %= MAX_DEBUG_LOGGED_MESSAGES;
+ debug->NextMsgLength = debug->Log[debug->NextMsg].length;
+ }
+}
- if (bufSize < length && buf != NULL)
- return 0;
+static struct gl_debug_msg *
+debug_get_group_message(struct gl_debug_state *debug)
+{
+ return &debug->DebugGroupMsgs[debug->GroupStackDepth];
+}
- if (severity) {
- *severity = debug_severity_enums[msg->severity];
- if (caller == MESSAGE_LOG_ARB)
- *severity = remap_severity(*severity);
- }
+static void
+debug_push_group(struct gl_debug_state *debug)
+{
+ const GLint gstack = debug->GroupStackDepth;
+ int s, t, sev;
- if (source) {
- *source = debug_source_enums[msg->source];
- }
+ /* inherit the control volume of the debug group previously residing on
+ * the top of the debug group stack
+ */
+ for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) {
+ for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) {
+ const struct gl_debug_namespace *nspace =
+ &debug->Namespaces[gstack][s][t];
+ struct gl_debug_namespace *next =
+ &debug->Namespaces[gstack + 1][s][t];
- if (type) {
- *type = debug_type_enums[msg->type];
- if (caller == MESSAGE_LOG_ARB)
- *type = remap_type(*type);
- }
+ /* copy id settings */
+ next->IDs = _mesa_HashClone(nspace->IDs);
- if (id) {
- *id = msg->id;
- }
+ for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) {
+ struct simple_node *node;
+
+ /* copy default settings for unknown ids */
+ debug->Defaults[gstack + 1][sev][s][t] =
+ debug->Defaults[gstack][sev][s][t];
- if (buf) {
- assert(msg->message[length-1] == '\0');
- (void) strncpy(buf, msg->message, (size_t)length);
+ /* copy known id severity settings */
+ make_empty_list(&next->Severity[sev]);
+ foreach(node, &nspace->Severity[sev]) {
+ const struct gl_debug_severity *entry =
+ (const struct gl_debug_severity *) node;
+ struct gl_debug_severity *copy;
+
+ copy = malloc(sizeof *entry);
+ if (!copy)
+ goto out;
+
+ copy->ID = entry->ID;
+ insert_at_tail(&next->Severity[sev], ©->link);
+ }
+ }
+ }
}
- if (msg->message != (char*)out_of_memory)
- free(msg->message);
- msg->message = NULL;
- msg->length = 0;
+out:
+ debug->GroupStackDepth++;
+}
- debug->NumMessages--;
- debug->NextMsg++;
- debug->NextMsg %= MAX_DEBUG_LOGGED_MESSAGES;
- debug->NextMsgLength = debug->Log[debug->NextMsg].length;
+static void
+debug_pop_group(struct gl_debug_state *debug)
+{
+ const GLint gstack = debug->GroupStackDepth;
- return length;
+ debug->GroupStackDepth--;
+ debug_clear_group(debug, gstack);
}
/**
- * 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.
- *
- * There is also special cases for handling values available in
- * GL_KHR_debug that are not avaliable in GL_ARB_debug_output
+ * Return debug state for the context. The debug state will be allocated
+ * and initialized upon the first call.
*/
-static GLboolean
-validate_params(struct gl_context *ctx, unsigned caller,
- const char *callerstr, GLenum source, GLenum type,
- GLenum severity)
+static struct gl_debug_state *
+_mesa_get_debug_state(struct gl_context *ctx)
{
-#define INSERT 1
-#define CONTROL 2
-#define INSERT_ARB 3
-#define CONTROL_ARB 4
- switch(source) {
- case GL_DEBUG_SOURCE_APPLICATION_ARB:
- case GL_DEBUG_SOURCE_THIRD_PARTY_ARB:
+ if (!ctx->Debug) {
+ ctx->Debug = debug_create();
+ if (!ctx->Debug) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "allocating debug state");
+ }
+ }
+
+ 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;
- 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 || caller == INSERT_ARB)
- break;
- case GL_DONT_CARE:
- if (caller == CONTROL || caller == CONTROL_ARB)
- break;
default:
- goto error;
+ assert(!"unknown debug output param");
+ break;
}
- 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:
+ 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;
+
+ debug = ctx->Debug;
+ if (!debug)
+ 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->NumMessages;
+ break;
+ case GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH:
+ val = debug->NextMsgLength;
+ break;
+ case GL_DEBUG_GROUP_STACK_DEPTH:
+ val = debug->GroupStackDepth;
break;
- case GL_DEBUG_TYPE_MARKER:
- /* this value is only valid for GL_KHR_debug functions */
- if (caller == CONTROL || caller == INSERT)
- break;
- case GL_DONT_CARE:
- if (caller == CONTROL || caller == CONTROL_ARB)
- break;
default:
- goto error;
+ assert(!"unknown debug output param");
+ val = 0;
+ break;
}
- switch(severity) {
- case GL_DEBUG_SEVERITY_HIGH_ARB:
- case GL_DEBUG_SEVERITY_MEDIUM_ARB:
- case GL_DEBUG_SEVERITY_LOW_ARB:
+ 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;
+
+ debug = ctx->Debug;
+ if (!debug)
+ 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;
- case GL_DEBUG_SEVERITY_NOTIFICATION:
- /* this value is only valid for GL_KHR_debug functions */
- if (caller == CONTROL || caller == INSERT)
- break;
- case GL_DONT_CARE:
- if (caller == CONTROL || caller == CONTROL_ARB)
- break;
default:
- goto error;
+ assert(!"unknown debug output param");
+ val = NULL;
+ break;
}
- 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;
+ return val;
}
/**
- * 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.
+ * Log a client or driver debug message.
*/
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)
+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);
- int s, t, sev, smax, tmax, sevmax;
- const GLint gstack = debug ? debug->GroupStackDepth : 0;
if (!debug)
return;
- if (source == MESA_DEBUG_SOURCE_COUNT) {
- source = 0;
- smax = MESA_DEBUG_SOURCE_COUNT;
- } else {
- smax = source+1;
- }
+ if (!debug_is_message_enabled(debug, source, type, id, severity))
+ return;
- if (type == MESA_DEBUG_TYPE_COUNT) {
- type = 0;
- tmax = MESA_DEBUG_TYPE_COUNT;
- } else {
- tmax = type+1;
- }
+ if (debug->Callback) {
+ GLenum gl_type = debug_type_enums[type];
+ GLenum gl_severity = debug_severity_enums[severity];
- if (severity == MESA_DEBUG_SEVERITY_COUNT) {
- severity = 0;
- sevmax = MESA_DEBUG_SEVERITY_COUNT;
- } else {
- sevmax = severity+1;
+ debug->Callback(debug_source_enums[source], gl_type, id, gl_severity,
+ len, buf, debug->CallbackData);
+ 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_log_message(debug, source, type, id, severity, len, buf);
+}
- /* change the default for IDs we've never seen before. */
- debug->Defaults[gstack][sev][s][t] = enabled;
- /* Now change the state of IDs we *have* seen... */
- foreach(node, &debug->Namespaces[gstack][s][t].Severity[sev]) {
- entry = (struct gl_debug_severity *)node;
- set_message_state(ctx, s, t, entry->ID, enabled);
- }
- }
- }
+/**
+ * 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;
}
-}
-
-/**
- * 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)
-{
- 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);
+ 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:
+ 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;
+ }
- for (i = 0; i < count; i++)
- set_message_state(ctx, source, type, ids[i], enabled);
+ 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;
- if (count)
- return;
+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);
- control_messages(ctx, source, type, severity, enabled);
+ return GL_FALSE;
}
-/**
- * This is a generic message control function for use by both
- * glDebugMessageControlARB and glDebugMessageControl.
- */
-static void
-message_control(GLenum gl_source, GLenum gl_type,
- GLenum gl_severity,
- GLsizei count, const GLuint *ids,
- GLboolean enabled,
- unsigned caller, const char *callerstr)
+static GLboolean
+validate_length(struct gl_context *ctx, const char *callerstr, GLsizei length)
{
- GET_CURRENT_CONTEXT(ctx);
-
- if (count < 0) {
+ if (length >= MAX_DEBUG_MESSAGE_LENGTH) {
_mesa_error(ctx, GL_INVALID_VALUE,
- "%s(count=%d : count must not be negative)", callerstr,
- count);
- return;
- }
-
- if (!validate_params(ctx, caller, 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;
+ "%s(length=%d, which is not less than "
+ "GL_MAX_DEBUG_MESSAGE_LENGTH=%d)", callerstr, length,
+ MAX_DEBUG_MESSAGE_LENGTH);
+ return GL_FALSE;
}
- control_app_messages(ctx, gl_source, gl_type, gl_severity,
- count, ids, enabled);
+ return GL_TRUE;
}
-/**
- * This is a generic message insert function.
- * Validation of source, type and severity parameters should be done
- * before calling this funtion.
- */
-static void
-message_insert(GLenum source, GLenum type, GLuint id,
- GLenum severity, GLint length, const GLchar *buf,
- const char *callerstr)
+void GLAPIENTRY
+_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, 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,
- "%s(length=%d, which is not less than "
- "GL_MAX_DEBUG_MESSAGE_LENGTH=%d)", callerstr, length,
- MAX_DEBUG_MESSAGE_LENGTH);
- return;
- }
-
- log_msg(ctx,
- gl_enum_to_debug_source(source),
+ log_msg(ctx, gl_enum_to_debug_source(source),
gl_enum_to_debug_type(type), id,
- gl_enum_to_debug_severity(severity), length, buf);
+ gl_enum_to_debug_severity(severity),
+ length, buf);
}
-/**
- * This is a generic message insert function for use by both
- * glGetDebugMessageLogARB and glGetDebugMessageLog.
- */
-static GLuint
-get_message_log(GLuint count, GLsizei logSize, GLenum *sources,
- GLenum *types, GLenum *ids, GLenum *severities,
- GLsizei *lengths, GLchar *messageLog,
- unsigned caller, const char *callerstr)
+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;
GLuint ret;
if (!messageLog)
if (logSize < 0) {
_mesa_error(ctx, GL_INVALID_VALUE,
- "%s(logSize=%d : logSize must not be negative)", callerstr,
- logSize);
+ "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 = get_msg(ctx, sources, types, ids, severities,
- logSize, messageLog, caller);
- if (!written)
+ const struct gl_debug_msg *msg = debug_fetch_message(debug);
+
+ if (!msg)
+ break;
+
+ assert(msg->length > 0 && msg->length == debug->NextMsgLength);
+
+ 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;
}
-static void
-do_nothing(GLuint key, void *data, void *userData)
-{
-}
-
-
-/**
- * Free context state pertaining to error/debug state for the given stack
- * depth.
- */
-static void
-free_errors_data(struct gl_context *ctx, GLint gstack)
-{
- struct gl_debug_state *debug = ctx->Debug;
- enum mesa_debug_type t;
- enum mesa_debug_source s;
- enum mesa_debug_severity sev;
-
- assert(debug);
-
- /* 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(debug->Namespaces[gstack][s][t].IDs,
- do_nothing, NULL);
- _mesa_DeleteHashTable(debug->Namespaces[gstack][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,
- &debug->Namespaces[gstack][s][t].Severity[sev]) {
- entry = (struct gl_debug_severity *)node;
- free(entry);
- }
- }
- }
- }
-}
-
-
void GLAPIENTRY
-_mesa_DebugMessageInsert(GLenum source, GLenum type, GLuint id,
- GLenum severity, GLint length,
- const GLchar *buf)
+_mesa_DebugMessageControl(GLenum gl_source, GLenum gl_type,
+ GLenum gl_severity, GLsizei count,
+ const GLuint *ids, GLboolean enabled)
{
- const char *callerstr = "glDebugMessageInsert";
-
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 (!validate_params(ctx, INSERT, callerstr, source, type, severity))
- return; /* GL_INVALID_ENUM */
-
- message_insert(source, type, id, severity, length, buf, callerstr);
-}
-
-
-GLuint GLAPIENTRY
-_mesa_GetDebugMessageLog(GLuint count, GLsizei logSize, GLenum *sources,
- GLenum *types, GLenum *ids, GLenum *severities,
- GLsizei *lengths, GLchar *messageLog)
-{
- const char *callerstr = "glGetDebugMessageLog";
+ if (count < 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "%s(count=%d : count must not be negative)", callerstr,
+ count);
+ return;
+ }
- return get_message_log(count, logSize, sources, types, ids, severities,
- lengths, messageLog, MESSAGE_LOG, callerstr);
-}
+ 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;
+ }
-void GLAPIENTRY
-_mesa_DebugMessageControl(GLenum source, GLenum type, GLenum severity,
- GLsizei count, const GLuint *ids,
- GLboolean enabled)
-{
- const char *callerstr = "glDebugMessageControl";
+ debug = _mesa_get_debug_state(ctx);
+ if (!debug)
+ return;
- message_control(source, type, severity, count, ids,
- enabled, CONTROL, callerstr);
+ 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);
+ }
}
if (debug) {
debug->Callback = callback;
debug->CallbackData = userParam;
- debug->ARBCallback = GL_FALSE;
}
}
GET_CURRENT_CONTEXT(ctx);
struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
const char *callerstr = "glPushDebugGroup";
- int s, t, sev;
- GLint prevStackDepth;
- GLint currStackDepth;
struct gl_debug_msg *emptySlot;
if (!debug)
return;
}
- message_insert(source, GL_DEBUG_TYPE_PUSH_GROUP, id,
- GL_DEBUG_SEVERITY_NOTIFICATION, length,
- message, callerstr);
-
- prevStackDepth = debug->GroupStackDepth;
- debug->GroupStackDepth++;
- currStackDepth = debug->GroupStackDepth;
-
- /* pop reuses the message details from push so we store this */
if (length < 0)
length = strlen(message);
- emptySlot = &debug->DebugGroupMsgs[debug->GroupStackDepth];
- store_message_details(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);
-
- /* inherit the control volume of the debug group previously residing on
- * the top of the debug group stack
- */
- for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) {
- for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) {
- /* copy id settings */
- debug->Namespaces[currStackDepth][s][t].IDs =
- _mesa_HashClone(debug->Namespaces[prevStackDepth][s][t].IDs);
-
- for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) {
- struct gl_debug_severity *entry, *prevEntry;
- struct simple_node *node;
+ if (!validate_length(ctx, callerstr, length))
+ return; /* GL_INVALID_VALUE */
- /* copy default settings for unknown ids */
- debug->Defaults[currStackDepth][sev][s][t] =
- debug->Defaults[prevStackDepth][sev][s][t];
+ log_msg(ctx, gl_enum_to_debug_source(source),
+ MESA_DEBUG_TYPE_PUSH_GROUP, id,
+ MESA_DEBUG_SEVERITY_NOTIFICATION, length,
+ message);
- /* copy known id severity settings */
- make_empty_list(&debug->Namespaces[currStackDepth][s][t].Severity[sev]);
- foreach(node, &debug->Namespaces[prevStackDepth][s][t].Severity[sev]) {
- prevEntry = (struct gl_debug_severity *)node;
- entry = malloc(sizeof *entry);
- if (!entry)
- return;
-
- entry->ID = prevEntry->ID;
- insert_at_tail(&debug->Namespaces[currStackDepth][s][t].Severity[sev], &entry->link);
- }
- }
- }
- }
+ /* 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);
}
struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
const char *callerstr = "glPopDebugGroup";
struct gl_debug_msg *gdmessage;
- GLint prevStackDepth;
if (!debug)
return;
return;
}
- prevStackDepth = debug->GroupStackDepth;
- debug->GroupStackDepth--;
+ debug_pop_group(debug);
- gdmessage = &debug->DebugGroupMsgs[prevStackDepth];
- /* using log_msg() directly here as verification of parameters
- * already done in push
- */
+ 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);
- if (gdmessage->message != (char*)out_of_memory)
- free(gdmessage->message);
- gdmessage->message = NULL;
- gdmessage->length = 0;
-
- /* free popped debug group data */
- free_errors_data(ctx, prevStackDepth);
-}
-
-
-void GLAPIENTRY
-_mesa_DebugMessageInsertARB(GLenum source, GLenum type, GLuint id,
- GLenum severity, GLint length,
- const GLcharARB *buf)
-{
- const char *callerstr = "glDebugMessageInsertARB";
-
- GET_CURRENT_CONTEXT(ctx);
-
- if (!validate_params(ctx, INSERT_ARB, callerstr, source, type, severity))
- return; /* GL_INVALID_ENUM */
-
- message_insert(source, type, id, severity, length, buf, callerstr);
-}
-
-
-GLuint GLAPIENTRY
-_mesa_GetDebugMessageLogARB(GLuint count, GLsizei logSize, GLenum *sources,
- GLenum *types, GLenum *ids, GLenum *severities,
- GLsizei *lengths, GLcharARB *messageLog)
-{
- const char *callerstr = "glGetDebugMessageLogARB";
-
- return get_message_log(count, logSize, sources, types, ids, severities,
- lengths, messageLog, MESSAGE_LOG_ARB, callerstr);
-}
-
-
-void GLAPIENTRY
-_mesa_DebugMessageControlARB(GLenum gl_source, GLenum gl_type,
- GLenum gl_severity,
- GLsizei count, const GLuint *ids,
- GLboolean enabled)
-{
- const char *callerstr = "glDebugMessageControlARB";
-
- message_control(gl_source, gl_type, gl_severity, count, ids,
- enabled, CONTROL_ARB, callerstr);
-}
-
-
-void GLAPIENTRY
-_mesa_DebugMessageCallbackARB(GLDEBUGPROCARB 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;
- debug->ARBCallback = GL_TRUE;
- }
+ debug_message_clear(gdmessage);
}
}
-/**
- * Loop through debug group stack tearing down states for
- * filtering debug messages.
- */
void
_mesa_free_errors_data(struct gl_context *ctx)
{
if (ctx->Debug) {
- GLint i;
-
- for (i = 0; i <= ctx->Debug->GroupStackDepth; i++) {
- free_errors_data(ctx, i);
- }
+ debug_destroy(ctx->Debug);
+ /* set to NULL just in case it is used before context is completely gone. */
+ ctx->Debug = NULL;
}
}
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,
- error_msg_id,
- 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];
projects / mesa.git / blobdiff