static mtx_t DynamicIDMutex = _MTX_INITIALIZER_NP;
static GLuint NextDynamicID = 1;
-struct gl_debug_severity
+/**
+ * A namespace element.
+ */
+struct gl_debug_element
{
struct simple_node link;
+
GLuint ID;
+ /* at which severity levels (mesa_debug_severity) is the message enabled */
+ GLbitfield State;
+};
+
+struct gl_debug_namespace
+{
+ struct simple_node Elements;
+ GLbitfield DefaultState;
+};
+
+struct gl_debug_group {
+ struct gl_debug_namespace Namespaces[MESA_DEBUG_SOURCE_COUNT][MESA_DEBUG_TYPE_COUNT];
+};
+
+/**
+ * An error, warning, or other piece of debug information for an application
+ * to consume via GL_ARB_debug_output/GL_KHR_debug.
+ */
+struct gl_debug_message
+{
+ enum mesa_debug_source source;
+ enum mesa_debug_type type;
+ GLuint id;
+ enum mesa_debug_severity severity;
+ GLsizei length;
+ GLcharARB *message;
+};
+
+/**
+ * Debug message log. It works like a ring buffer.
+ */
+struct gl_debug_log {
+ struct gl_debug_message Messages[MAX_DEBUG_LOGGED_MESSAGES];
+ GLint NextMessage;
+ GLint NumMessages;
+};
+
+struct gl_debug_state
+{
+ GLDEBUGPROC Callback;
+ const void *CallbackData;
+ GLboolean SyncOutput;
+ GLboolean DebugOutput;
+
+ struct gl_debug_group *Groups[MAX_DEBUG_GROUP_STACK_DEPTH];
+ struct gl_debug_message GroupMessages[MAX_DEBUG_GROUP_STACK_DEPTH];
+ GLint GroupStackDepth;
+
+ struct gl_debug_log Log;
};
static char out_of_memory[] = "Debugging error: out of memory";
}
}
-
-/*
- * We store a bitfield in the hash table, with five possible values total.
- *
- * The ENABLED_BIT's purpose is self-explanatory.
- *
- * The FOUND_BIT is needed to differentiate the value of DISABLED from
- * the value returned by HashTableLookup() when it can't find the given key.
- *
- * The KNOWN_SEVERITY bit is a bit complicated:
- *
- * A client may call Control() with an array of IDs, then call Control()
- * on all message IDs of a certain severity, then Insert() one of the
- * previously specified IDs, giving us a known severity level, then call
- * Control() on all message IDs of a certain severity level again.
- *
- * After the first call, those IDs will have a FOUND_BIT, but will not
- * exist in any severity-specific list, so the second call will not
- * impact them. This is undesirable but unavoidable given the API:
- * The only entrypoint that gives a severity for a client-defined ID
- * is the Insert() call.
- *
- * For the sake of Control(), we want to maintain the invariant
- * that an ID will either appear in none of the three severity lists,
- * or appear once, to minimize pointless duplication and potential surprises.
- *
- * Because Insert() is the only place that will learn an ID's severity,
- * it should insert an ID into the appropriate list, but only if the ID
- * doesn't exist in it or any other list yet. Because searching all three
- * lists at O(n) is needlessly expensive, we store KNOWN_SEVERITY.
- */
-enum {
- FOUND_BIT = 1 << 0,
- ENABLED_BIT = 1 << 1,
- KNOWN_SEVERITY = 1 << 2,
-
- /* HashTable reserves zero as a return value meaning 'not found' */
- NOT_FOUND = 0,
- DISABLED = FOUND_BIT,
- ENABLED = ENABLED_BIT | FOUND_BIT
-};
-
static void
-debug_message_clear(struct gl_debug_msg *msg)
+debug_message_clear(struct gl_debug_message *msg)
{
if (msg->message != (char*)out_of_memory)
free(msg->message);
}
static void
-debug_message_store(struct gl_debug_msg *msg,
+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,
}
}
+static void
+debug_namespace_init(struct gl_debug_namespace *ns)
+{
+ make_empty_list(&ns->Elements);
+
+ /* Enable all the messages with severity HIGH or MEDIUM by default */
+ ns->DefaultState = (1 << MESA_DEBUG_SEVERITY_HIGH) |
+ (1 << MESA_DEBUG_SEVERITY_MEDIUM);
+}
+
+static void
+debug_namespace_clear(struct gl_debug_namespace *ns)
+{
+ struct simple_node *node, *tmp;
+
+ foreach_s(node, tmp, &ns->Elements)
+ free(node);
+}
+
+static bool
+debug_namespace_copy(struct gl_debug_namespace *dst,
+ const struct gl_debug_namespace *src)
+{
+ struct simple_node *node;
+
+ dst->DefaultState = src->DefaultState;
+
+ make_empty_list(&dst->Elements);
+ foreach(node, &src->Elements) {
+ const struct gl_debug_element *elem =
+ (const struct gl_debug_element *) node;
+ struct gl_debug_element *copy;
+
+ copy = malloc(sizeof(*copy));
+ if (!copy) {
+ debug_namespace_clear(dst);
+ return false;
+ }
+
+ copy->ID = elem->ID;
+ copy->State = elem->State;
+ insert_at_tail(&dst->Elements, ©->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.
*/
debug_create(void)
{
struct gl_debug_state *debug;
- int s, t, sev;
+ int s, t;
debug = CALLOC_STRUCT(gl_debug_state);
if (!debug)
return NULL;
- /* 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]);
+ 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->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]);
- }
- }
+ for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++)
+ debug_namespace_init(&debug->Groups[0]->Namespaces[s][t]);
}
return debug;
}
-static void
-debug_clear_group_cb(GLuint key, void *data, void *userData)
+/**
+ * Return true if the top debug group points to the group below it.
+ */
+static bool
+debug_is_group_read_only(const struct gl_debug_state *debug)
{
+ const GLint gstack = debug->GroupStackDepth;
+ return (gstack > 0 && debug->Groups[gstack] == debug->Groups[gstack - 1]);
}
/**
- * Free debug state for the given stack depth.
+ * Make the top debug group writable.
*/
-static void
-debug_clear_group(struct gl_debug_state *debug, GLint gstack)
+static bool
+debug_make_group_writable(struct gl_debug_state *debug)
{
- enum mesa_debug_type t;
- enum mesa_debug_source s;
- enum mesa_debug_severity sev;
+ const GLint gstack = debug->GroupStackDepth;
+ const struct gl_debug_group *src = debug->Groups[gstack];
+ struct gl_debug_group *dst;
+ int s, t;
- /* 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 (!debug_is_group_read_only(debug))
+ return true;
- _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;
+ dst = malloc(sizeof(*dst));
+ if (!dst)
+ return false;
- foreach_s(node, tmp, &nspace->Severity[sev]) {
- entry = (struct gl_debug_severity *)node;
- free(entry);
+ 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->GroupStackDepth;
+
+ if (!debug_is_group_read_only(debug)) {
+ struct gl_debug_group *grp = debug->Groups[gstack];
+ int s, t;
+
+ for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) {
+ for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++)
+ debug_namespace_clear(&grp->Namespaces[s][t]);
+ }
+
+ free(grp);
+ }
+
+ debug->Groups[gstack] = NULL;
}
/**
static void
debug_destroy(struct gl_debug_state *debug)
{
- GLint i;
-
- for (i = 0; i <= debug->GroupStackDepth; i++)
- debug_clear_group(debug, i);
+ while (debug->GroupStackDepth > 0) {
+ debug_clear_group(debug);
+ debug->GroupStackDepth--;
+ }
+ debug_clear_group(debug);
free(debug);
}
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;
+ const GLint gstack = debug->GroupStackDepth;
+ struct gl_debug_namespace *ns;
- /* 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;
+ debug_make_group_writable(debug);
+ ns = &debug->Groups[gstack]->Namespaces[source][type];
- if (state == NOT_FOUND)
- state = enabled ? ENABLED : DISABLED;
- else {
- if (enabled)
- state |= ENABLED_BIT;
- else
- state &= ~ENABLED_BIT;
- }
-
- if (id)
- _mesa_HashInsert(nspace->IDs, id, (void*)state);
- else
- nspace->ZeroID = state;
+ debug_namespace_set(ns, id, enabled);
}
/*
GLboolean enabled)
{
const GLint gstack = debug->GroupStackDepth;
- int s, t, sev, smax, tmax, sevmax;
+ int s, t, smax, tmax;
if (source == MESA_DEBUG_SOURCE_COUNT) {
source = 0;
tmax = type+1;
}
- if (severity == MESA_DEBUG_SEVERITY_COUNT) {
- severity = 0;
- sevmax = MESA_DEBUG_SEVERITY_COUNT;
- } else {
- sevmax = severity+1;
- }
-
- 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;
-
- /* change the default for IDs we've never seen before. */
- debug->Defaults[gstack][sev][s][t] = enabled;
+ debug_make_group_writable(debug);
- /* 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);
- }
- }
+ 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(struct gl_debug_state *debug,
+debug_is_message_enabled(const struct gl_debug_state *debug,
enum mesa_debug_source source,
enum mesa_debug_type type,
GLuint id,
enum mesa_debug_severity severity)
{
const GLint gstack = debug->GroupStackDepth;
- struct gl_debug_namespace *nspace =
- &debug->Namespaces[gstack][source][type];
- uintptr_t state = 0;
+ struct gl_debug_group *grp = debug->Groups[gstack];
+ struct gl_debug_namespace *nspace = &grp->Namespaces[source][type];
if (!debug->DebugOutput)
return false;
- /* 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);
+ return debug_namespace_get(nspace, id, severity);
}
/**
enum mesa_debug_severity severity,
GLsizei len, const char *buf)
{
+ struct gl_debug_log *log = &debug->Log;
GLint nextEmpty;
- struct gl_debug_msg *emptySlot;
+ struct gl_debug_message *emptySlot;
assert(len >= 0 && len < MAX_DEBUG_MESSAGE_LENGTH);
- if (debug->NumMessages == MAX_DEBUG_LOGGED_MESSAGES)
+ if (log->NumMessages == MAX_DEBUG_LOGGED_MESSAGES)
return;
- nextEmpty = (debug->NextMsg + debug->NumMessages)
- % MAX_DEBUG_LOGGED_MESSAGES;
- emptySlot = &debug->Log[nextEmpty];
+ nextEmpty = (log->NextMessage + log->NumMessages)
+ % MAX_DEBUG_LOGGED_MESSAGES;
+ emptySlot = &log->Messages[nextEmpty];
debug_message_store(emptySlot, source, type,
id, severity, len, buf);
- if (debug->NumMessages == 0)
- debug->NextMsgLength = debug->Log[debug->NextMsg].length;
-
- debug->NumMessages++;
+ log->NumMessages++;
}
/**
* Return the oldest debug message out of the log.
*/
-static const struct gl_debug_msg *
+static const struct gl_debug_message *
debug_fetch_message(const struct gl_debug_state *debug)
{
- return (debug->NumMessages) ? &debug->Log[debug->NextMsg] : NULL;
+ const struct gl_debug_log *log = &debug->Log;
+
+ return (log->NumMessages) ? &log->Messages[log->NextMessage] : NULL;
}
/**
static void
debug_delete_messages(struct gl_debug_state *debug, unsigned count)
{
- if (count > debug->NumMessages)
- count = debug->NumMessages;
+ struct gl_debug_log *log = &debug->Log;
+
+ if (count > log->NumMessages)
+ count = log->NumMessages;
while (count--) {
- struct gl_debug_msg *msg = &debug->Log[debug->NextMsg];
+ struct gl_debug_message *msg = &log->Messages[log->NextMessage];
- assert(msg->length > 0 && msg->length == debug->NextMsgLength);
debug_message_clear(msg);
- debug->NumMessages--;
- debug->NextMsg++;
- debug->NextMsg %= MAX_DEBUG_LOGGED_MESSAGES;
- debug->NextMsgLength = debug->Log[debug->NextMsg].length;
+ log->NumMessages--;
+ log->NextMessage++;
+ log->NextMessage %= MAX_DEBUG_LOGGED_MESSAGES;
}
}
-static struct gl_debug_msg *
+static struct gl_debug_message *
debug_get_group_message(struct gl_debug_state *debug)
{
- return &debug->DebugGroupMsgs[debug->GroupStackDepth];
+ return &debug->GroupMessages[debug->GroupStackDepth];
}
static void
debug_push_group(struct gl_debug_state *debug)
{
const GLint gstack = debug->GroupStackDepth;
- int s, t, sev;
-
- /* 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];
-
- /* copy id settings */
- next->IDs = _mesa_HashClone(nspace->IDs);
-
- 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];
-
- /* 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);
- }
- }
- }
- }
-out:
+ /* just point to the previous stack */
+ debug->Groups[gstack + 1] = debug->Groups[gstack];
debug->GroupStackDepth++;
}
static void
debug_pop_group(struct gl_debug_state *debug)
{
- const GLint gstack = debug->GroupStackDepth;
-
+ debug_clear_group(debug);
debug->GroupStackDepth--;
- debug_clear_group(debug, gstack);
}
* Return debug state for the context. The debug state will be allocated
* and initialized upon the first call.
*/
-struct gl_debug_state *
+static struct gl_debug_state *
_mesa_get_debug_state(struct gl_context *ctx)
{
if (!ctx->Debug) {
return ctx->Debug;
}
+/**
+ * Set the integer debug state specified by \p pname. This can be called from
+ * _mesa_set_enable for example.
+ */
+bool
+_mesa_set_debug_state_int(struct gl_context *ctx, GLenum pname, GLint val)
+{
+ struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
+
+ if (!debug)
+ return false;
+
+ switch (pname) {
+ case GL_DEBUG_OUTPUT:
+ debug->DebugOutput = (val != 0);
+ break;
+ case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB:
+ debug->SyncOutput = (val != 0);
+ break;
+ default:
+ assert(!"unknown debug output param");
+ break;
+ }
+
+ 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->Log.NumMessages;
+ break;
+ case GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH:
+ val = (debug->Log.NumMessages) ?
+ debug->Log.Messages[debug->Log.NextMessage].length : 0;
+ break;
+ case GL_DEBUG_GROUP_STACK_DEPTH:
+ val = debug->GroupStackDepth;
+ break;
+ default:
+ assert(!"unknown debug output param");
+ val = 0;
+ break;
+ }
+
+ 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;
+ default:
+ assert(!"unknown debug output param");
+ val = NULL;
+ break;
+ }
+
+ return val;
+}
+
/**
* Log a client or driver debug message.
}
-/**
- * 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)
+static GLboolean
+validate_length(struct gl_context *ctx, const char *callerstr, GLsizei length)
{
- GET_CURRENT_CONTEXT(ctx);
-
- if (length < 0)
- length = strlen(buf);
-
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;
+ return GL_FALSE;
}
- log_msg(ctx,
- gl_enum_to_debug_source(source),
- gl_enum_to_debug_type(type), id,
- gl_enum_to_debug_severity(severity), length, buf);
+ return GL_TRUE;
}
if (!validate_params(ctx, INSERT, callerstr, source, type, severity))
return; /* GL_INVALID_ENUM */
- message_insert(source, type, id, severity, length, buf, callerstr);
+ if (length < 0)
+ length = strlen(buf);
+ if (!validate_length(ctx, callerstr, length))
+ 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);
}
return 0;
for (ret = 0; ret < count; ret++) {
- const struct gl_debug_msg *msg = debug_fetch_message(debug);
+ const struct gl_debug_message *msg = debug_fetch_message(debug);
if (!msg)
break;
- assert(msg->length > 0 && msg->length == debug->NextMsgLength);
-
if (logSize < msg->length && messageLog != NULL)
break;
GET_CURRENT_CONTEXT(ctx);
struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
const char *callerstr = "glPushDebugGroup";
- struct gl_debug_msg *emptySlot;
+ struct gl_debug_message *emptySlot;
if (!debug)
return;
if (length < 0)
length = strlen(message);
+ if (!validate_length(ctx, callerstr, length))
+ return; /* GL_INVALID_VALUE */
- message_insert(source, GL_DEBUG_TYPE_PUSH_GROUP, id,
- GL_DEBUG_SEVERITY_NOTIFICATION, length,
- message, callerstr);
+ log_msg(ctx, gl_enum_to_debug_source(source),
+ MESA_DEBUG_TYPE_PUSH_GROUP, id,
+ MESA_DEBUG_SEVERITY_NOTIFICATION, length,
+ message);
/* pop reuses the message details from push so we store this */
emptySlot = debug_get_group_message(debug);
GET_CURRENT_CONTEXT(ctx);
struct gl_debug_state *debug = _mesa_get_debug_state(ctx);
const char *callerstr = "glPopDebugGroup";
- struct gl_debug_msg *gdmessage;
+ struct gl_debug_message *gdmessage;
if (!debug)
return;
debug_pop_group(debug);
gdmessage = debug_get_group_message(debug);
- /* using log_msg() directly here as verification of parameters
- * already done in push
- */
log_msg(ctx, gdmessage->source,
gl_enum_to_debug_type(GL_DEBUG_TYPE_POP_GROUP),
gdmessage->id,
_mesa_record_error(ctx, error);
}
+void
+_mesa_error_no_memory(const char *caller)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "out of memory in %s", caller);
+}
/**
* Report debug information. Print error message to stderr via fprintf().