3 * Mesa debugging and error handling functions.
7 * Mesa 3-D graphics library
9 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
11 * Permission is hereby granted, free of charge, to any person obtaining a
12 * copy of this software and associated documentation files (the "Software"),
13 * to deal in the Software without restriction, including without limitation
14 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 * and/or sell copies of the Software, and to permit persons to whom the
16 * Software is furnished to do so, subject to the following conditions:
18 * The above copyright notice and this permission notice shall be included
19 * in all copies or substantial portions of the Software.
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
25 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
26 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
27 * OTHER DEALINGS IN THE SOFTWARE.
39 #include "hash_table.h"
41 static mtx_t DynamicIDMutex
= _MTX_INITIALIZER_NP
;
42 static GLuint NextDynamicID
= 1;
44 struct gl_debug_severity
46 struct simple_node link
;
50 static char out_of_memory
[] = "Debugging error: out of memory";
52 static const GLenum debug_source_enums
[] = {
54 GL_DEBUG_SOURCE_WINDOW_SYSTEM
,
55 GL_DEBUG_SOURCE_SHADER_COMPILER
,
56 GL_DEBUG_SOURCE_THIRD_PARTY
,
57 GL_DEBUG_SOURCE_APPLICATION
,
58 GL_DEBUG_SOURCE_OTHER
,
61 static const GLenum debug_type_enums
[] = {
63 GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR
,
64 GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR
,
65 GL_DEBUG_TYPE_PORTABILITY
,
66 GL_DEBUG_TYPE_PERFORMANCE
,
69 GL_DEBUG_TYPE_PUSH_GROUP
,
70 GL_DEBUG_TYPE_POP_GROUP
,
73 static const GLenum debug_severity_enums
[] = {
74 GL_DEBUG_SEVERITY_LOW
,
75 GL_DEBUG_SEVERITY_MEDIUM
,
76 GL_DEBUG_SEVERITY_HIGH
,
77 GL_DEBUG_SEVERITY_NOTIFICATION
,
81 static enum mesa_debug_source
82 gl_enum_to_debug_source(GLenum e
)
86 for (i
= 0; i
< Elements(debug_source_enums
); i
++) {
87 if (debug_source_enums
[i
] == e
)
93 static enum mesa_debug_type
94 gl_enum_to_debug_type(GLenum e
)
98 for (i
= 0; i
< Elements(debug_type_enums
); i
++) {
99 if (debug_type_enums
[i
] == e
)
105 static enum mesa_debug_severity
106 gl_enum_to_debug_severity(GLenum e
)
110 for (i
= 0; i
< Elements(debug_severity_enums
); i
++) {
111 if (debug_severity_enums
[i
] == e
)
119 * Handles generating a GL_ARB_debug_output message ID generated by the GL or
122 * The GL API has this "ID" mechanism, where the intention is to allow a
123 * client to filter in/out messages based on source, type, and ID. Of course,
124 * building a giant enum list of all debug output messages that Mesa might
125 * generate is ridiculous, so instead we have our caller pass us a pointer to
126 * static storage where the ID should get stored. This ID will be shared
127 * across all contexts for that message (which seems like a desirable
128 * property, even if it's not expected by the spec), but note that it won't be
129 * the same between executions if messages aren't generated in the same order.
132 debug_get_id(GLuint
*id
)
135 mtx_lock(&DynamicIDMutex
);
137 *id
= NextDynamicID
++;
138 mtx_unlock(&DynamicIDMutex
);
144 * We store a bitfield in the hash table, with five possible values total.
146 * The ENABLED_BIT's purpose is self-explanatory.
148 * The FOUND_BIT is needed to differentiate the value of DISABLED from
149 * the value returned by HashTableLookup() when it can't find the given key.
151 * The KNOWN_SEVERITY bit is a bit complicated:
153 * A client may call Control() with an array of IDs, then call Control()
154 * on all message IDs of a certain severity, then Insert() one of the
155 * previously specified IDs, giving us a known severity level, then call
156 * Control() on all message IDs of a certain severity level again.
158 * After the first call, those IDs will have a FOUND_BIT, but will not
159 * exist in any severity-specific list, so the second call will not
160 * impact them. This is undesirable but unavoidable given the API:
161 * The only entrypoint that gives a severity for a client-defined ID
162 * is the Insert() call.
164 * For the sake of Control(), we want to maintain the invariant
165 * that an ID will either appear in none of the three severity lists,
166 * or appear once, to minimize pointless duplication and potential surprises.
168 * Because Insert() is the only place that will learn an ID's severity,
169 * it should insert an ID into the appropriate list, but only if the ID
170 * doesn't exist in it or any other list yet. Because searching all three
171 * lists at O(n) is needlessly expensive, we store KNOWN_SEVERITY.
175 ENABLED_BIT
= 1 << 1,
176 KNOWN_SEVERITY
= 1 << 2,
178 /* HashTable reserves zero as a return value meaning 'not found' */
180 DISABLED
= FOUND_BIT
,
181 ENABLED
= ENABLED_BIT
| FOUND_BIT
185 debug_message_clear(struct gl_debug_msg
*msg
)
187 if (msg
->message
!= (char*)out_of_memory
)
194 debug_message_store(struct gl_debug_msg
*msg
,
195 enum mesa_debug_source source
,
196 enum mesa_debug_type type
, GLuint id
,
197 enum mesa_debug_severity severity
,
198 GLsizei len
, const char *buf
)
200 assert(!msg
->message
&& !msg
->length
);
202 msg
->message
= malloc(len
+1);
204 (void) strncpy(msg
->message
, buf
, (size_t)len
);
205 msg
->message
[len
] = '\0';
208 msg
->source
= source
;
211 msg
->severity
= severity
;
213 static GLuint oom_msg_id
= 0;
214 debug_get_id(&oom_msg_id
);
217 msg
->message
= out_of_memory
;
218 msg
->length
= strlen(out_of_memory
)+1;
219 msg
->source
= MESA_DEBUG_SOURCE_OTHER
;
220 msg
->type
= MESA_DEBUG_TYPE_ERROR
;
221 msg
->id
= oom_msg_id
;
222 msg
->severity
= MESA_DEBUG_SEVERITY_HIGH
;
227 * Allocate and initialize context debug state.
229 static struct gl_debug_state
*
232 struct gl_debug_state
*debug
;
235 debug
= CALLOC_STRUCT(gl_debug_state
);
239 /* Enable all the messages with severity HIGH or MEDIUM by default. */
240 memset(debug
->Defaults
[0][MESA_DEBUG_SEVERITY_HIGH
], GL_TRUE
,
241 sizeof debug
->Defaults
[0][MESA_DEBUG_SEVERITY_HIGH
]);
242 memset(debug
->Defaults
[0][MESA_DEBUG_SEVERITY_MEDIUM
], GL_TRUE
,
243 sizeof debug
->Defaults
[0][MESA_DEBUG_SEVERITY_MEDIUM
]);
244 memset(debug
->Defaults
[0][MESA_DEBUG_SEVERITY_LOW
], GL_FALSE
,
245 sizeof debug
->Defaults
[0][MESA_DEBUG_SEVERITY_LOW
]);
247 /* Initialize state for filtering known debug messages. */
248 for (s
= 0; s
< MESA_DEBUG_SOURCE_COUNT
; s
++) {
249 for (t
= 0; t
< MESA_DEBUG_TYPE_COUNT
; t
++) {
250 debug
->Namespaces
[0][s
][t
].IDs
= _mesa_NewHashTable();
251 assert(debug
->Namespaces
[0][s
][t
].IDs
);
253 for (sev
= 0; sev
< MESA_DEBUG_SEVERITY_COUNT
; sev
++) {
254 make_empty_list(&debug
->Namespaces
[0][s
][t
].Severity
[sev
]);
263 * Sets the state of the given message source/type/ID tuple.
266 debug_set_message_enable(struct gl_debug_state
*debug
,
267 enum mesa_debug_source source
,
268 enum mesa_debug_type type
,
269 GLuint id
, GLboolean enabled
)
271 GLint gstack
= debug
->GroupStackDepth
;
272 struct gl_debug_namespace
*nspace
=
273 &debug
->Namespaces
[gstack
][source
][type
];
276 /* In addition to not being able to store zero as a value, HashTable also
277 * can't use zero as a key.
280 state
= (uintptr_t)_mesa_HashLookup(nspace
->IDs
, id
);
282 state
= nspace
->ZeroID
;
284 if (state
== NOT_FOUND
)
285 state
= enabled
? ENABLED
: DISABLED
;
288 state
|= ENABLED_BIT
;
290 state
&= ~ENABLED_BIT
;
294 _mesa_HashInsert(nspace
->IDs
, id
, (void*)state
);
296 nspace
->ZeroID
= state
;
300 * Set the state of all message IDs found in the given intersection of
301 * 'source', 'type', and 'severity'. The _COUNT enum can be used for
302 * GL_DONT_CARE (include all messages in the class).
304 * This requires both setting the state of all previously seen message
305 * IDs in the hash table, and setting the default state for all
306 * applicable combinations of source/type/severity, so that all the
307 * yet-unknown message IDs that may be used in the future will be
308 * impacted as if they were already known.
311 debug_set_message_enable_all(struct gl_debug_state
*debug
,
312 enum mesa_debug_source source
,
313 enum mesa_debug_type type
,
314 enum mesa_debug_severity severity
,
317 const GLint gstack
= debug
->GroupStackDepth
;
318 int s
, t
, sev
, smax
, tmax
, sevmax
;
320 if (source
== MESA_DEBUG_SOURCE_COUNT
) {
322 smax
= MESA_DEBUG_SOURCE_COUNT
;
327 if (type
== MESA_DEBUG_TYPE_COUNT
) {
329 tmax
= MESA_DEBUG_TYPE_COUNT
;
334 if (severity
== MESA_DEBUG_SEVERITY_COUNT
) {
336 sevmax
= MESA_DEBUG_SEVERITY_COUNT
;
341 for (sev
= severity
; sev
< sevmax
; sev
++) {
342 for (s
= source
; s
< smax
; s
++) {
343 for (t
= type
; t
< tmax
; t
++) {
344 struct simple_node
*node
;
345 struct gl_debug_severity
*entry
;
347 /* change the default for IDs we've never seen before. */
348 debug
->Defaults
[gstack
][sev
][s
][t
] = enabled
;
350 /* Now change the state of IDs we *have* seen... */
351 foreach(node
, &debug
->Namespaces
[gstack
][s
][t
].Severity
[sev
]) {
352 entry
= (struct gl_debug_severity
*)node
;
353 debug_set_message_enable(debug
, s
, t
, entry
->ID
, enabled
);
361 * Returns if the given message source/type/ID tuple is enabled.
364 debug_is_message_enabled(struct gl_debug_state
*debug
,
365 enum mesa_debug_source source
,
366 enum mesa_debug_type type
,
368 enum mesa_debug_severity severity
)
370 const GLint gstack
= debug
->GroupStackDepth
;
371 struct gl_debug_namespace
*nspace
=
372 &debug
->Namespaces
[gstack
][source
][type
];
375 if (!debug
->DebugOutput
)
378 /* In addition to not being able to store zero as a value, HashTable also
379 * can't use zero as a key.
382 state
= (uintptr_t)_mesa_HashLookup(nspace
->IDs
, id
);
384 state
= nspace
->ZeroID
;
386 /* Only do this once for each ID. This makes sure the ID exists in,
387 * at most, one list, and does not pointlessly appear multiple times.
389 if (!(state
& KNOWN_SEVERITY
)) {
390 struct gl_debug_severity
*entry
;
392 if (state
== NOT_FOUND
) {
393 if (debug
->Defaults
[gstack
][severity
][source
][type
])
399 entry
= malloc(sizeof *entry
);
403 state
|= KNOWN_SEVERITY
;
406 _mesa_HashInsert(nspace
->IDs
, id
, (void*)state
);
408 nspace
->ZeroID
= state
;
411 insert_at_tail(&nspace
->Severity
[severity
], &entry
->link
);
414 return (state
& ENABLED_BIT
);
418 * 'buf' is not necessarily a null-terminated string. When logging, copy
419 * 'len' characters from it, store them in a new, null-terminated string,
420 * and remember the number of bytes used by that string, *including*
421 * the null terminator this time.
424 debug_log_message(struct gl_debug_state
*debug
,
425 enum mesa_debug_source source
,
426 enum mesa_debug_type type
, GLuint id
,
427 enum mesa_debug_severity severity
,
428 GLsizei len
, const char *buf
)
431 struct gl_debug_msg
*emptySlot
;
433 assert(len
>= 0 && len
< MAX_DEBUG_MESSAGE_LENGTH
);
435 if (debug
->NumMessages
== MAX_DEBUG_LOGGED_MESSAGES
)
438 nextEmpty
= (debug
->NextMsg
+ debug
->NumMessages
)
439 % MAX_DEBUG_LOGGED_MESSAGES
;
440 emptySlot
= &debug
->Log
[nextEmpty
];
442 debug_message_store(emptySlot
, source
, type
,
443 id
, severity
, len
, buf
);
445 if (debug
->NumMessages
== 0)
446 debug
->NextMsgLength
= debug
->Log
[debug
->NextMsg
].length
;
448 debug
->NumMessages
++;
452 * Return the oldest debug message out of the log.
454 static const struct gl_debug_msg
*
455 debug_fetch_message(const struct gl_debug_state
*debug
)
457 return (debug
->NumMessages
) ? &debug
->Log
[debug
->NextMsg
] : NULL
;
461 * Delete the oldest debug messages out of the log.
464 debug_delete_messages(struct gl_debug_state
*debug
, unsigned count
)
466 if (count
> debug
->NumMessages
)
467 count
= debug
->NumMessages
;
470 struct gl_debug_msg
*msg
= &debug
->Log
[debug
->NextMsg
];
472 assert(msg
->length
> 0 && msg
->length
== debug
->NextMsgLength
);
473 debug_message_clear(msg
);
475 debug
->NumMessages
--;
477 debug
->NextMsg
%= MAX_DEBUG_LOGGED_MESSAGES
;
478 debug
->NextMsgLength
= debug
->Log
[debug
->NextMsg
].length
;
482 static struct gl_debug_msg
*
483 debug_get_group_message(struct gl_debug_state
*debug
)
485 return &debug
->DebugGroupMsgs
[debug
->GroupStackDepth
];
489 debug_push_group(struct gl_debug_state
*debug
)
491 const GLint gstack
= debug
->GroupStackDepth
;
494 /* inherit the control volume of the debug group previously residing on
495 * the top of the debug group stack
497 for (s
= 0; s
< MESA_DEBUG_SOURCE_COUNT
; s
++) {
498 for (t
= 0; t
< MESA_DEBUG_TYPE_COUNT
; t
++) {
499 const struct gl_debug_namespace
*nspace
=
500 &debug
->Namespaces
[gstack
][s
][t
];
501 struct gl_debug_namespace
*next
=
502 &debug
->Namespaces
[gstack
+ 1][s
][t
];
504 /* copy id settings */
505 next
->IDs
= _mesa_HashClone(nspace
->IDs
);
507 for (sev
= 0; sev
< MESA_DEBUG_SEVERITY_COUNT
; sev
++) {
508 struct simple_node
*node
;
510 /* copy default settings for unknown ids */
511 debug
->Defaults
[gstack
+ 1][sev
][s
][t
] =
512 debug
->Defaults
[gstack
][sev
][s
][t
];
514 /* copy known id severity settings */
515 make_empty_list(&next
->Severity
[sev
]);
516 foreach(node
, &nspace
->Severity
[sev
]) {
517 const struct gl_debug_severity
*entry
=
518 (const struct gl_debug_severity
*) node
;
519 struct gl_debug_severity
*copy
;
521 copy
= malloc(sizeof *entry
);
525 copy
->ID
= entry
->ID
;
526 insert_at_tail(&next
->Severity
[sev
], ©
->link
);
533 debug
->GroupStackDepth
++;
538 * Return debug state for the context. The debug state will be allocated
539 * and initialized upon the first call.
541 struct gl_debug_state
*
542 _mesa_get_debug_state(struct gl_context
*ctx
)
545 ctx
->Debug
= debug_create();
547 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "allocating debug state");
557 should_log(struct gl_context
*ctx
,
558 enum mesa_debug_source source
,
559 enum mesa_debug_type type
,
561 enum mesa_debug_severity severity
)
563 struct gl_debug_state
*debug
;
566 /* no debug state set so far */
570 debug
= _mesa_get_debug_state(ctx
);
572 return debug_is_message_enabled(debug
, source
, type
, id
, severity
);
579 set_message_state(struct gl_context
*ctx
,
580 enum mesa_debug_source source
,
581 enum mesa_debug_type type
,
582 GLuint id
, GLboolean enabled
)
584 struct gl_debug_state
*debug
= _mesa_get_debug_state(ctx
);
587 debug_set_message_enable(debug
, source
, type
, id
, enabled
);
593 * Log a client or driver debug message.
596 log_msg(struct gl_context
*ctx
, enum mesa_debug_source source
,
597 enum mesa_debug_type type
, GLuint id
,
598 enum mesa_debug_severity severity
, GLint len
, const char *buf
)
600 struct gl_debug_state
*debug
= _mesa_get_debug_state(ctx
);
605 if (!should_log(ctx
, source
, type
, id
, severity
))
608 if (debug
->Callback
) {
609 GLenum gl_type
= debug_type_enums
[type
];
610 GLenum gl_severity
= debug_severity_enums
[severity
];
612 debug
->Callback(debug_source_enums
[source
], gl_type
, id
, gl_severity
,
613 len
, buf
, debug
->CallbackData
);
617 debug_log_message(debug
, source
, type
, id
, severity
, len
, buf
);
622 * Pop the oldest debug message out of the log.
623 * Writes the message string, including the null terminator, into 'buf',
624 * using up to 'bufSize' bytes. If 'bufSize' is too small, or
625 * if 'buf' is NULL, nothing is written.
627 * Returns the number of bytes written on success, or when 'buf' is NULL,
628 * the number that would have been written. A return value of 0
632 get_msg(struct gl_context
*ctx
, GLenum
*source
, GLenum
*type
,
633 GLuint
*id
, GLenum
*severity
, GLsizei bufSize
, char *buf
)
635 struct gl_debug_state
*debug
= _mesa_get_debug_state(ctx
);
636 const struct gl_debug_msg
*msg
;
642 msg
= debug_fetch_message(debug
);
646 msg
= &debug
->Log
[debug
->NextMsg
];
647 length
= msg
->length
;
649 assert(length
> 0 && length
== debug
->NextMsgLength
);
651 if (bufSize
< length
&& buf
!= NULL
)
655 *severity
= debug_severity_enums
[msg
->severity
];
659 *source
= debug_source_enums
[msg
->source
];
663 *type
= debug_type_enums
[msg
->type
];
671 assert(msg
->message
[length
-1] == '\0');
672 (void) strncpy(buf
, msg
->message
, (size_t)length
);
675 debug_delete_messages(debug
, 1);
682 * Verify that source, type, and severity are valid enums.
684 * The 'caller' param is used for handling values available
685 * only in glDebugMessageInsert or glDebugMessageControl
688 validate_params(struct gl_context
*ctx
, unsigned caller
,
689 const char *callerstr
, GLenum source
, GLenum type
,
695 case GL_DEBUG_SOURCE_APPLICATION_ARB
:
696 case GL_DEBUG_SOURCE_THIRD_PARTY_ARB
:
698 case GL_DEBUG_SOURCE_API_ARB
:
699 case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB
:
700 case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB
:
701 case GL_DEBUG_SOURCE_OTHER_ARB
:
702 if (caller
!= INSERT
)
707 if (caller
== CONTROL
)
716 case GL_DEBUG_TYPE_ERROR_ARB
:
717 case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB
:
718 case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB
:
719 case GL_DEBUG_TYPE_PERFORMANCE_ARB
:
720 case GL_DEBUG_TYPE_PORTABILITY_ARB
:
721 case GL_DEBUG_TYPE_OTHER_ARB
:
722 case GL_DEBUG_TYPE_MARKER
:
724 case GL_DEBUG_TYPE_PUSH_GROUP
:
725 case GL_DEBUG_TYPE_POP_GROUP
:
727 if (caller
== CONTROL
)
736 case GL_DEBUG_SEVERITY_HIGH_ARB
:
737 case GL_DEBUG_SEVERITY_MEDIUM_ARB
:
738 case GL_DEBUG_SEVERITY_LOW_ARB
:
739 case GL_DEBUG_SEVERITY_NOTIFICATION
:
742 if (caller
== CONTROL
)
752 _mesa_error(ctx
, GL_INVALID_ENUM
, "bad values passed to %s"
753 "(source=0x%x, type=0x%x, severity=0x%x)", callerstr
,
754 source
, type
, severity
);
761 control_messages(struct gl_context
*ctx
,
762 enum mesa_debug_source source
,
763 enum mesa_debug_type type
,
764 enum mesa_debug_severity severity
,
767 struct gl_debug_state
*debug
= _mesa_get_debug_state(ctx
);
772 debug_set_message_enable_all(debug
, source
, type
, severity
, enabled
);
777 * Debugging-message namespaces with the source APPLICATION or THIRD_PARTY
778 * require special handling, since the IDs in them are controlled by clients,
779 * not the OpenGL implementation.
781 * 'count' is the length of the array 'ids'. If 'count' is nonzero, all
782 * the given IDs in the namespace defined by 'esource' and 'etype'
785 * If 'count' is zero, this sets the state of all IDs that match
786 * the combination of 'esource', 'etype', and 'eseverity'.
789 control_app_messages(struct gl_context
*ctx
, GLenum esource
, GLenum etype
,
790 GLenum eseverity
, GLsizei count
, const GLuint
*ids
,
794 enum mesa_debug_source source
= gl_enum_to_debug_source(esource
);
795 enum mesa_debug_type type
= gl_enum_to_debug_type(etype
);
796 enum mesa_debug_severity severity
= gl_enum_to_debug_severity(eseverity
);
798 for (i
= 0; i
< count
; i
++)
799 set_message_state(ctx
, source
, type
, ids
[i
], enabled
);
804 control_messages(ctx
, source
, type
, severity
, enabled
);
809 * This is a generic message insert function.
810 * Validation of source, type and severity parameters should be done
811 * before calling this funtion.
814 message_insert(GLenum source
, GLenum type
, GLuint id
,
815 GLenum severity
, GLint length
, const GLchar
*buf
,
816 const char *callerstr
)
818 GET_CURRENT_CONTEXT(ctx
);
821 length
= strlen(buf
);
823 if (length
>= MAX_DEBUG_MESSAGE_LENGTH
) {
824 _mesa_error(ctx
, GL_INVALID_VALUE
,
825 "%s(length=%d, which is not less than "
826 "GL_MAX_DEBUG_MESSAGE_LENGTH=%d)", callerstr
, length
,
827 MAX_DEBUG_MESSAGE_LENGTH
);
832 gl_enum_to_debug_source(source
),
833 gl_enum_to_debug_type(type
), id
,
834 gl_enum_to_debug_severity(severity
), length
, buf
);
839 do_nothing(GLuint key
, void *data
, void *userData
)
845 * Free context state pertaining to error/debug state for the given stack
849 free_errors_data(struct gl_context
*ctx
, GLint gstack
)
851 struct gl_debug_state
*debug
= ctx
->Debug
;
852 enum mesa_debug_type t
;
853 enum mesa_debug_source s
;
854 enum mesa_debug_severity sev
;
858 /* Tear down state for filtering debug messages. */
859 for (s
= 0; s
< MESA_DEBUG_SOURCE_COUNT
; s
++) {
860 for (t
= 0; t
< MESA_DEBUG_TYPE_COUNT
; t
++) {
861 _mesa_HashDeleteAll(debug
->Namespaces
[gstack
][s
][t
].IDs
,
863 _mesa_DeleteHashTable(debug
->Namespaces
[gstack
][s
][t
].IDs
);
864 for (sev
= 0; sev
< MESA_DEBUG_SEVERITY_COUNT
; sev
++) {
865 struct simple_node
*node
, *tmp
;
866 struct gl_debug_severity
*entry
;
869 &debug
->Namespaces
[gstack
][s
][t
].Severity
[sev
]) {
870 entry
= (struct gl_debug_severity
*)node
;
880 _mesa_DebugMessageInsert(GLenum source
, GLenum type
, GLuint id
,
881 GLenum severity
, GLint length
,
884 const char *callerstr
= "glDebugMessageInsert";
886 GET_CURRENT_CONTEXT(ctx
);
888 if (!validate_params(ctx
, INSERT
, callerstr
, source
, type
, severity
))
889 return; /* GL_INVALID_ENUM */
891 message_insert(source
, type
, id
, severity
, length
, buf
, callerstr
);
896 _mesa_GetDebugMessageLog(GLuint count
, GLsizei logSize
, GLenum
*sources
,
897 GLenum
*types
, GLenum
*ids
, GLenum
*severities
,
898 GLsizei
*lengths
, GLchar
*messageLog
)
900 GET_CURRENT_CONTEXT(ctx
);
907 _mesa_error(ctx
, GL_INVALID_VALUE
,
908 "glGetDebugMessageLog(logSize=%d : logSize must not be"
909 " negative)", logSize
);
913 for (ret
= 0; ret
< count
; ret
++) {
914 GLsizei written
= get_msg(ctx
, sources
, types
, ids
, severities
,
915 logSize
, messageLog
);
920 messageLog
+= written
;
943 _mesa_DebugMessageControl(GLenum gl_source
, GLenum gl_type
,
944 GLenum gl_severity
, GLsizei count
,
945 const GLuint
*ids
, GLboolean enabled
)
947 const char *callerstr
= "glDebugMessageControl";
949 GET_CURRENT_CONTEXT(ctx
);
952 _mesa_error(ctx
, GL_INVALID_VALUE
,
953 "%s(count=%d : count must not be negative)", callerstr
,
958 if (!validate_params(ctx
, CONTROL
, callerstr
, gl_source
, gl_type
,
960 return; /* GL_INVALID_ENUM */
962 if (count
&& (gl_severity
!= GL_DONT_CARE
|| gl_type
== GL_DONT_CARE
963 || gl_source
== GL_DONT_CARE
)) {
964 _mesa_error(ctx
, GL_INVALID_OPERATION
,
965 "%s(When passing an array of ids, severity must be"
966 " GL_DONT_CARE, and source and type must not be GL_DONT_CARE.",
971 control_app_messages(ctx
, gl_source
, gl_type
, gl_severity
,
972 count
, ids
, enabled
);
977 _mesa_DebugMessageCallback(GLDEBUGPROC callback
, const void *userParam
)
979 GET_CURRENT_CONTEXT(ctx
);
980 struct gl_debug_state
*debug
= _mesa_get_debug_state(ctx
);
982 debug
->Callback
= callback
;
983 debug
->CallbackData
= userParam
;
989 _mesa_PushDebugGroup(GLenum source
, GLuint id
, GLsizei length
,
990 const GLchar
*message
)
992 GET_CURRENT_CONTEXT(ctx
);
993 struct gl_debug_state
*debug
= _mesa_get_debug_state(ctx
);
994 const char *callerstr
= "glPushDebugGroup";
995 struct gl_debug_msg
*emptySlot
;
1000 if (debug
->GroupStackDepth
>= MAX_DEBUG_GROUP_STACK_DEPTH
-1) {
1001 _mesa_error(ctx
, GL_STACK_OVERFLOW
, "%s", callerstr
);
1006 case GL_DEBUG_SOURCE_APPLICATION
:
1007 case GL_DEBUG_SOURCE_THIRD_PARTY
:
1010 _mesa_error(ctx
, GL_INVALID_ENUM
, "bad value passed to %s"
1011 "(source=0x%x)", callerstr
, source
);
1016 length
= strlen(message
);
1018 message_insert(source
, GL_DEBUG_TYPE_PUSH_GROUP
, id
,
1019 GL_DEBUG_SEVERITY_NOTIFICATION
, length
,
1020 message
, callerstr
);
1022 /* pop reuses the message details from push so we store this */
1023 emptySlot
= debug_get_group_message(debug
);
1024 debug_message_store(emptySlot
,
1025 gl_enum_to_debug_source(source
),
1026 gl_enum_to_debug_type(GL_DEBUG_TYPE_PUSH_GROUP
),
1028 gl_enum_to_debug_severity(GL_DEBUG_SEVERITY_NOTIFICATION
),
1031 debug_push_group(debug
);
1036 _mesa_PopDebugGroup(void)
1038 GET_CURRENT_CONTEXT(ctx
);
1039 struct gl_debug_state
*debug
= _mesa_get_debug_state(ctx
);
1040 const char *callerstr
= "glPopDebugGroup";
1041 struct gl_debug_msg
*gdmessage
;
1042 GLint prevStackDepth
;
1047 if (debug
->GroupStackDepth
<= 0) {
1048 _mesa_error(ctx
, GL_STACK_UNDERFLOW
, "%s", callerstr
);
1052 prevStackDepth
= debug
->GroupStackDepth
;
1053 debug
->GroupStackDepth
--;
1055 gdmessage
= debug_get_group_message(debug
);
1056 /* using log_msg() directly here as verification of parameters
1057 * already done in push
1059 log_msg(ctx
, gdmessage
->source
,
1060 gl_enum_to_debug_type(GL_DEBUG_TYPE_POP_GROUP
),
1062 gl_enum_to_debug_severity(GL_DEBUG_SEVERITY_NOTIFICATION
),
1063 gdmessage
->length
, gdmessage
->message
);
1065 if (gdmessage
->message
!= (char*)out_of_memory
)
1066 free(gdmessage
->message
);
1067 gdmessage
->message
= NULL
;
1068 gdmessage
->length
= 0;
1070 /* free popped debug group data */
1071 free_errors_data(ctx
, prevStackDepth
);
1076 _mesa_init_errors(struct gl_context
*ctx
)
1083 * Loop through debug group stack tearing down states for
1084 * filtering debug messages. Then free debug output state.
1087 _mesa_free_errors_data(struct gl_context
*ctx
)
1092 for (i
= 0; i
<= ctx
->Debug
->GroupStackDepth
; i
++) {
1093 free_errors_data(ctx
, i
);
1096 /* set to NULL just in case it is used before context is completely gone. */
1102 /**********************************************************************/
1103 /** \name Diagnostics */
1107 output_if_debug(const char *prefixString
, const char *outputString
,
1110 static int debug
= -1;
1111 static FILE *fout
= NULL
;
1113 /* Init the local 'debug' var once.
1114 * Note: the _mesa_init_debug() function should have been called
1115 * by now so MESA_DEBUG_FLAGS will be initialized.
1118 /* If MESA_LOG_FILE env var is set, log Mesa errors, warnings,
1119 * etc to the named file. Otherwise, output to stderr.
1121 const char *logFile
= _mesa_getenv("MESA_LOG_FILE");
1123 fout
= fopen(logFile
, "w");
1127 /* in debug builds, print messages unless MESA_DEBUG="silent" */
1128 if (MESA_DEBUG_FLAGS
& DEBUG_SILENT
)
1133 /* in release builds, be silent unless MESA_DEBUG is set */
1134 debug
= _mesa_getenv("MESA_DEBUG") != NULL
;
1138 /* Now only print the string if we're required to do so. */
1140 fprintf(fout
, "%s: %s", prefixString
, outputString
);
1142 fprintf(fout
, "\n");
1145 #if defined(_WIN32) && !defined(_WIN32_WCE)
1146 /* stderr from windows applications without console is not usually
1147 * visible, so communicate with the debugger instead */
1150 _mesa_snprintf(buf
, sizeof(buf
), "%s: %s%s", prefixString
, outputString
, newline
? "\n" : "");
1151 OutputDebugStringA(buf
);
1159 * When a new type of error is recorded, print a message describing
1160 * previous errors which were accumulated.
1163 flush_delayed_errors( struct gl_context
*ctx
)
1165 char s
[MAX_DEBUG_MESSAGE_LENGTH
];
1167 if (ctx
->ErrorDebugCount
) {
1168 _mesa_snprintf(s
, MAX_DEBUG_MESSAGE_LENGTH
, "%d similar %s errors",
1169 ctx
->ErrorDebugCount
,
1170 _mesa_lookup_enum_by_nr(ctx
->ErrorValue
));
1172 output_if_debug("Mesa", s
, GL_TRUE
);
1174 ctx
->ErrorDebugCount
= 0;
1180 * Report a warning (a recoverable error condition) to stderr if
1181 * either DEBUG is defined or the MESA_DEBUG env var is set.
1183 * \param ctx GL context.
1184 * \param fmtString printf()-like format string.
1187 _mesa_warning( struct gl_context
*ctx
, const char *fmtString
, ... )
1189 char str
[MAX_DEBUG_MESSAGE_LENGTH
];
1191 va_start( args
, fmtString
);
1192 (void) _mesa_vsnprintf( str
, MAX_DEBUG_MESSAGE_LENGTH
, fmtString
, args
);
1196 flush_delayed_errors( ctx
);
1198 output_if_debug("Mesa warning", str
, GL_TRUE
);
1203 * Report an internal implementation problem.
1204 * Prints the message to stderr via fprintf().
1206 * \param ctx GL context.
1207 * \param fmtString problem description string.
1210 _mesa_problem( const struct gl_context
*ctx
, const char *fmtString
, ... )
1213 char str
[MAX_DEBUG_MESSAGE_LENGTH
];
1214 static int numCalls
= 0;
1218 if (numCalls
< 50) {
1221 va_start( args
, fmtString
);
1222 _mesa_vsnprintf( str
, MAX_DEBUG_MESSAGE_LENGTH
, fmtString
, args
);
1224 fprintf(stderr
, "Mesa %s implementation error: %s\n",
1225 PACKAGE_VERSION
, str
);
1226 fprintf(stderr
, "Please report at " PACKAGE_BUGREPORT
"\n");
1232 should_output(struct gl_context
*ctx
, GLenum error
, const char *fmtString
)
1234 static GLint debug
= -1;
1236 /* Check debug environment variable only once:
1239 const char *debugEnv
= _mesa_getenv("MESA_DEBUG");
1242 if (debugEnv
&& strstr(debugEnv
, "silent"))
1255 if (ctx
->ErrorValue
!= error
||
1256 ctx
->ErrorDebugFmtString
!= fmtString
) {
1257 flush_delayed_errors( ctx
);
1258 ctx
->ErrorDebugFmtString
= fmtString
;
1259 ctx
->ErrorDebugCount
= 0;
1262 ctx
->ErrorDebugCount
++;
1269 _mesa_gl_debug(struct gl_context
*ctx
,
1271 enum mesa_debug_type type
,
1272 enum mesa_debug_severity severity
,
1273 const char *fmtString
, ...)
1275 char s
[MAX_DEBUG_MESSAGE_LENGTH
];
1281 va_start(args
, fmtString
);
1282 len
= _mesa_vsnprintf(s
, MAX_DEBUG_MESSAGE_LENGTH
, fmtString
, args
);
1285 log_msg(ctx
, MESA_DEBUG_SOURCE_API
, type
, *id
, severity
, len
, s
);
1290 * Record an OpenGL state error. These usually occur when the user
1291 * passes invalid parameters to a GL function.
1293 * If debugging is enabled (either at compile-time via the DEBUG macro, or
1294 * run-time via the MESA_DEBUG environment variable), report the error with
1297 * \param ctx the GL context.
1298 * \param error the error value.
1299 * \param fmtString printf() style format string, followed by optional args
1302 _mesa_error( struct gl_context
*ctx
, GLenum error
, const char *fmtString
, ... )
1304 GLboolean do_output
, do_log
;
1305 /* Ideally this would be set up by the caller, so that we had proper IDs
1306 * per different message.
1308 static GLuint error_msg_id
= 0;
1310 debug_get_id(&error_msg_id
);
1312 do_output
= should_output(ctx
, error
, fmtString
);
1313 do_log
= should_log(ctx
,
1314 MESA_DEBUG_SOURCE_API
,
1315 MESA_DEBUG_TYPE_ERROR
,
1317 MESA_DEBUG_SEVERITY_HIGH
);
1319 if (do_output
|| do_log
) {
1320 char s
[MAX_DEBUG_MESSAGE_LENGTH
], s2
[MAX_DEBUG_MESSAGE_LENGTH
];
1324 va_start(args
, fmtString
);
1325 len
= _mesa_vsnprintf(s
, MAX_DEBUG_MESSAGE_LENGTH
, fmtString
, args
);
1328 if (len
>= MAX_DEBUG_MESSAGE_LENGTH
) {
1329 /* Too long error message. Whoever calls _mesa_error should use
1336 len
= _mesa_snprintf(s2
, MAX_DEBUG_MESSAGE_LENGTH
, "%s in %s",
1337 _mesa_lookup_enum_by_nr(error
), s
);
1338 if (len
>= MAX_DEBUG_MESSAGE_LENGTH
) {
1339 /* Same as above. */
1344 /* Print the error to stderr if needed. */
1346 output_if_debug("Mesa: User error", s2
, GL_TRUE
);
1349 /* Log the error via ARB_debug_output if needed.*/
1351 log_msg(ctx
, MESA_DEBUG_SOURCE_API
, MESA_DEBUG_TYPE_ERROR
,
1352 error_msg_id
, MESA_DEBUG_SEVERITY_HIGH
, len
, s2
);
1356 /* Set the GL context error state for glGetError. */
1357 _mesa_record_error(ctx
, error
);
1362 * Report debug information. Print error message to stderr via fprintf().
1363 * No-op if DEBUG mode not enabled.
1365 * \param ctx GL context.
1366 * \param fmtString printf()-style format string, followed by optional args.
1369 _mesa_debug( const struct gl_context
*ctx
, const char *fmtString
, ... )
1372 char s
[MAX_DEBUG_MESSAGE_LENGTH
];
1374 va_start(args
, fmtString
);
1375 _mesa_vsnprintf(s
, MAX_DEBUG_MESSAGE_LENGTH
, fmtString
, args
);
1377 output_if_debug("Mesa", s
, GL_FALSE
);
1385 * Report debug information from the shader compiler via GL_ARB_debug_output.
1387 * \param ctx GL context.
1388 * \param type The namespace to which this message belongs.
1389 * \param id The message ID within the given namespace.
1390 * \param msg The message to output. Need not be null-terminated.
1391 * \param len The length of 'msg'. If negative, 'msg' must be null-terminated.
1394 _mesa_shader_debug( struct gl_context
*ctx
, GLenum type
, GLuint
*id
,
1395 const char *msg
, int len
)
1397 enum mesa_debug_source source
= MESA_DEBUG_SOURCE_SHADER_COMPILER
;
1398 enum mesa_debug_severity severity
= MESA_DEBUG_SEVERITY_HIGH
;
1405 /* Truncate the message if necessary. */
1406 if (len
>= MAX_DEBUG_MESSAGE_LENGTH
)
1407 len
= MAX_DEBUG_MESSAGE_LENGTH
- 1;
1409 log_msg(ctx
, source
, type
, *id
, severity
, len
, msg
);