src/gallium/auxiliary/util/u_debug.h

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 /**
  29  * @file
  30  * Cross-platform debugging helpers.
  31  *
  32  * For now it just has assert and printf replacements, but it might be extended
  33  * with stack trace reports and more advanced logging in the near future.
  34  *
  35  * @author Jose Fonseca <jfonseca@vmware.com>
  36  */
  37
  38 #ifndef U_DEBUG_H_
  39 #define U_DEBUG_H_
  40
  41
  42 #include "os/os_misc.h"
  43
  44 #include "pipe/p_format.h"
  45 #include "pipe/p_defines.h"
  46
  47
  48 #ifdef  __cplusplus
  49 extern "C" {
  50 #endif
  51
  52
  53 #if defined(__GNUC__)
  54 #define _util_printf_format(fmt, list) __attribute__ ((format (printf, fmt, list)))
  55 #else
  56 #define _util_printf_format(fmt, list)
  57 #endif
  58
  59 void _debug_vprintf(const char *format, va_list ap);
  60
  61
  62 static inline void
  63 _debug_printf(const char *format, ...)
  64 {
  65    va_list ap;
  66    va_start(ap, format);
  67    _debug_vprintf(format, ap);
  68    va_end(ap);
  69 }
  70
  71
  72 /**
  73  * Print debug messages.
  74  *
  75  * The actual channel used to output debug message is platform specific. To
  76  * avoid misformating or truncation, follow these rules of thumb:
  77  * - output whole lines
  78  * - avoid outputing large strings (512 bytes is the current maximum length
  79  * that is guaranteed to be printed in all platforms)
  80  */
  81 #if !defined(PIPE_OS_HAIKU)
  82 static inline void
  83 debug_printf(const char *format, ...) _util_printf_format(1,2);
  84
  85 static inline void
  86 debug_printf(const char *format, ...)
  87 {
  88 #ifdef DEBUG
  89    va_list ap;
  90    va_start(ap, format);
  91    _debug_vprintf(format, ap);
  92    va_end(ap);
  93 #else
  94    (void) format; /* silence warning */
  95 #endif
  96 }
  97 #else /* is Haiku */
  98 /* Haiku provides debug_printf in libroot with OS.h */
  99 #include <OS.h>
 100 #endif
 101
 102
 103 /*
 104  * ... isn't portable so we need to pass arguments in parentheses.
 105  *
 106  * usage:
 107  *    debug_printf_once(("answer: %i\n", 42));
 108  */
 109 #define debug_printf_once(args) \
 110    do { \
 111       static boolean once = TRUE; \
 112       if (once) { \
 113          once = FALSE; \
 114          debug_printf args; \
 115       } \
 116    } while (0)
 117
 118
 119 #ifdef DEBUG
 120 #define debug_vprintf(_format, _ap) _debug_vprintf(_format, _ap)
 121 #else
 122 #define debug_vprintf(_format, _ap) ((void)0)
 123 #endif
 124
 125
 126 #ifdef DEBUG
 127 /**
 128  * Dump a blob in hex to the same place that debug_printf sends its
 129  * messages.
 130  */
 131 void debug_print_blob( const char *name, const void *blob, unsigned size );
 132
 133 /* Print a message along with a prettified format string
 134  */
 135 void debug_print_format(const char *msg, unsigned fmt );
 136 #else
 137 #define debug_print_blob(_name, _blob, _size) ((void)0)
 138 #define debug_print_format(_msg, _fmt) ((void)0)
 139 #endif
 140
 141
 142 /**
 143  * Disable interactive error message boxes.
 144  *
 145  * Should be called as soon as possible for effectiveness.
 146  */
 147 void
 148 debug_disable_error_message_boxes(void);
 149
 150
 151 /**
 152  * Hard-coded breakpoint.
 153  */
 154 #ifdef DEBUG
 155 #define debug_break() os_break()
 156 #else /* !DEBUG */
 157 #define debug_break() ((void)0)
 158 #endif /* !DEBUG */
 159
 160
 161 long
 162 debug_get_num_option(const char *name, long dfault);
 163
 164 #ifdef _MSC_VER
 165 __declspec(noreturn)
 166 #endif
 167 void _debug_assert_fail(const char *expr,
 168                         const char *file,
 169                         unsigned line,
 170                         const char *function)
 171 #ifdef __GNUC__
 172    __attribute__((__noreturn__))
 173 #endif
 174 ;
 175
 176
 177 /**
 178  * Assert macro
 179  *
 180  * Do not expect that the assert call terminates -- errors must be handled
 181  * regardless of assert behavior.
 182  *
 183  * For non debug builds the assert macro will expand to a no-op, so do not
 184  * call functions with side effects in the assert expression.
 185  */
 186 #ifdef DEBUG
 187 #define debug_assert(expr) ((expr) ? (void)0 : _debug_assert_fail(#expr, __FILE__, __LINE__, __FUNCTION__))
 188 #else
 189 #define debug_assert(expr) (void)(0 && (expr))
 190 #endif
 191
 192
 193 /** Override standard assert macro */
 194 #ifdef assert
 195 #undef assert
 196 #endif
 197 #define assert(expr) debug_assert(expr)
 198
 199
 200 /**
 201  * Output the current function name.
 202  */
 203 #ifdef DEBUG
 204 #define debug_checkpoint() \
 205    _debug_printf("%s\n", __FUNCTION__)
 206 #else
 207 #define debug_checkpoint() \
 208    ((void)0)
 209 #endif
 210
 211
 212 /**
 213  * Output the full source code position.
 214  */
 215 #ifdef DEBUG
 216 #define debug_checkpoint_full() \
 217    _debug_printf("%s:%u:%s\n", __FILE__, __LINE__, __FUNCTION__)
 218 #else
 219 #define debug_checkpoint_full() \
 220    ((void)0)
 221 #endif
 222
 223
 224 /**
 225  * Output a warning message. Muted on release version.
 226  */
 227 #ifdef DEBUG
 228 #define debug_warning(__msg) \
 229    _debug_printf("%s:%u:%s: warning: %s\n", __FILE__, __LINE__, __FUNCTION__, __msg)
 230 #else
 231 #define debug_warning(__msg) \
 232    ((void)0)
 233 #endif
 234
 235
 236 /**
 237  * Emit a warning message, but only once.
 238  */
 239 #ifdef DEBUG
 240 #define debug_warn_once(__msg) \
 241    do { \
 242       static bool warned = FALSE; \
 243       if (!warned) { \
 244          _debug_printf("%s:%u:%s: one time warning: %s\n", \
 245                        __FILE__, __LINE__, __FUNCTION__, __msg); \
 246          warned = TRUE; \
 247       } \
 248    } while (0)
 249 #else
 250 #define debug_warn_once(__msg) \
 251    ((void)0)
 252 #endif
 253
 254
 255 /**
 256  * Output an error message. Not muted on release version.
 257  */
 258 #ifdef DEBUG
 259 #define debug_error(__msg) \
 260    _debug_printf("%s:%u:%s: error: %s\n", __FILE__, __LINE__, __FUNCTION__, __msg)
 261 #else
 262 #define debug_error(__msg) \
 263    _debug_printf("error: %s\n", __msg)
 264 #endif
 265
 266 /**
 267  * Output a debug log message to the debug info callback.
 268  */
 269 #define pipe_debug_message(cb, type, fmt, ...) do { \
 270    static unsigned id = 0; \
 271    if ((cb) && (cb)->debug_message) { \
 272       _pipe_debug_message(cb, &id, \
 273                           PIPE_DEBUG_TYPE_ ## type, \
 274                           fmt, ##__VA_ARGS__); \
 275    } \
 276 } while (0)
 277
 278 struct pipe_debug_callback;
 279
 280 void
 281 _pipe_debug_message(
 282    struct pipe_debug_callback *cb,
 283    unsigned *id,
 284    enum pipe_debug_type type,
 285    const char *fmt, ...) _util_printf_format(4, 5);
 286
 287
 288 /**
 289  * Used by debug_dump_enum and debug_dump_flags to describe symbols.
 290  */
 291 struct debug_named_value
 292 {
 293    const char *name;
 294    uint64_t value;
 295    const char *desc;
 296 };
 297
 298
 299 /**
 300  * Some C pre-processor magic to simplify creating named values.
 301  *
 302  * Example:
 303  * @code
 304  * static const debug_named_value my_names[] = {
 305  *    DEBUG_NAMED_VALUE(MY_ENUM_VALUE_X),
 306  *    DEBUG_NAMED_VALUE(MY_ENUM_VALUE_Y),
 307  *    DEBUG_NAMED_VALUE(MY_ENUM_VALUE_Z),
 308  *    DEBUG_NAMED_VALUE_END
 309  * };
 310  *
 311  *    ...
 312  *    debug_printf("%s = %s\n",
 313  *                 name,
 314  *                 debug_dump_enum(my_names, my_value));
 315  *    ...
 316  * @endcode
 317  */
 318 #define DEBUG_NAMED_VALUE(__symbol) {#__symbol, (unsigned long)__symbol, NULL}
 319 #define DEBUG_NAMED_VALUE_WITH_DESCRIPTION(__symbol, __desc) {#__symbol, (unsigned long)__symbol, __desc}
 320 #define DEBUG_NAMED_VALUE_END {NULL, 0, NULL}
 321
 322
 323 /**
 324  * Convert a enum value to a string.
 325  */
 326 const char *
 327 debug_dump_enum(const struct debug_named_value *names,
 328                 unsigned long value);
 329
 330 const char *
 331 debug_dump_enum_noprefix(const struct debug_named_value *names,
 332                          const char *prefix,
 333                          unsigned long value);
 334
 335
 336 /**
 337  * Convert binary flags value to a string.
 338  */
 339 const char *
 340 debug_dump_flags(const struct debug_named_value *names,
 341                  unsigned long value);
 342
 343
 344 /**
 345  * Function enter exit loggers
 346  */
 347 #ifdef DEBUG
 348 int debug_funclog_enter(const char* f, const int line, const char* file);
 349 void debug_funclog_exit(const char* f, const int line, const char* file);
 350 void debug_funclog_enter_exit(const char* f, const int line, const char* file);
 351
 352 #define DEBUG_FUNCLOG_ENTER() \
 353    int __debug_decleration_work_around = \
 354       debug_funclog_enter(__FUNCTION__, __LINE__, __FILE__)
 355 #define DEBUG_FUNCLOG_EXIT() \
 356    do { \
 357       (void)__debug_decleration_work_around; \
 358       debug_funclog_exit(__FUNCTION__, __LINE__, __FILE__); \
 359       return; \
 360    } while(0)
 361 #define DEBUG_FUNCLOG_EXIT_RET(ret) \
 362    do { \
 363       (void)__debug_decleration_work_around; \
 364       debug_funclog_exit(__FUNCTION__, __LINE__, __FILE__); \
 365       return ret; \
 366    } while(0)
 367 #define DEBUG_FUNCLOG_ENTER_EXIT() \
 368    debug_funclog_enter_exit(__FUNCTION__, __LINE__, __FILE__)
 369
 370 #else
 371 #define DEBUG_FUNCLOG_ENTER() \
 372    int __debug_decleration_work_around
 373 #define DEBUG_FUNCLOG_EXIT() \
 374    do { (void)__debug_decleration_work_around; return; } while(0)
 375 #define DEBUG_FUNCLOG_EXIT_RET(ret) \
 376    do { (void)__debug_decleration_work_around; return ret; } while(0)
 377 #define DEBUG_FUNCLOG_ENTER_EXIT()
 378 #endif
 379
 380
 381 /**
 382  * Get option.
 383  *
 384  * It is an alias for getenv on Linux.
 385  *
 386  * On Windows it reads C:\gallium.cfg, which is a text file with CR+LF line
 387  * endings with one option per line as
 388  *
 389  *   NAME=value
 390  *
 391  * This file must be terminated with an extra empty line.
 392  */
 393 const char *
 394 debug_get_option(const char *name, const char *dfault);
 395
 396 boolean
 397 debug_get_bool_option(const char *name, boolean dfault);
 398
 399 long
 400 debug_get_num_option(const char *name, long dfault);
 401
 402 uint64_t
 403 debug_get_flags_option(const char *name,
 404                        const struct debug_named_value *flags,
 405                        uint64_t dfault);
 406
 407 #define DEBUG_GET_ONCE_OPTION(suffix, name, dfault) \
 408 static const char * \
 409 debug_get_option_ ## suffix (void) \
 410 { \
 411    static boolean first = TRUE; \
 412    static const char * value; \
 413    if (first) { \
 414       first = FALSE; \
 415       value = debug_get_option(name, dfault); \
 416    } \
 417    return value; \
 418 }
 419
 420 #define DEBUG_GET_ONCE_BOOL_OPTION(sufix, name, dfault) \
 421 static boolean \
 422 debug_get_option_ ## sufix (void) \
 423 { \
 424    static boolean first = TRUE; \
 425    static boolean value; \
 426    if (first) { \
 427       first = FALSE; \
 428       value = debug_get_bool_option(name, dfault); \
 429    } \
 430    return value; \
 431 }
 432
 433 #define DEBUG_GET_ONCE_NUM_OPTION(sufix, name, dfault) \
 434 static long \
 435 debug_get_option_ ## sufix (void) \
 436 { \
 437    static boolean first = TRUE; \
 438    static long value; \
 439    if (first) { \
 440       first = FALSE; \
 441       value = debug_get_num_option(name, dfault); \
 442    } \
 443    return value; \
 444 }
 445
 446 #define DEBUG_GET_ONCE_FLAGS_OPTION(sufix, name, flags, dfault) \
 447 static unsigned long \
 448 debug_get_option_ ## sufix (void) \
 449 { \
 450    static boolean first = TRUE; \
 451    static unsigned long value; \
 452    if (first) { \
 453       first = FALSE; \
 454       value = debug_get_flags_option(name, flags, dfault); \
 455    } \
 456    return value; \
 457 }
 458
 459
 460 unsigned long
 461 debug_memory_begin(void);
 462
 463 void
 464 debug_memory_end(unsigned long beginning);
 465
 466
 467 #ifdef DEBUG
 468 struct pipe_context;
 469 struct pipe_surface;
 470 struct pipe_transfer;
 471 struct pipe_resource;
 472
 473 void debug_dump_image(const char *prefix,
 474                       enum pipe_format format, unsigned cpp,
 475                       unsigned width, unsigned height,
 476                       unsigned stride,
 477                       const void *data);
 478 void debug_dump_surface(struct pipe_context *pipe,
 479                         const char *prefix,
 480                         struct pipe_surface *surface);
 481 void debug_dump_texture(struct pipe_context *pipe,
 482                         const char *prefix,
 483                         struct pipe_resource *texture);
 484 void debug_dump_surface_bmp(struct pipe_context *pipe,
 485                             const char *filename,
 486                             struct pipe_surface *surface);
 487 void debug_dump_transfer_bmp(struct pipe_context *pipe,
 488                              const char *filename,
 489                              struct pipe_transfer *transfer, void *ptr);
 490 void debug_dump_float_rgba_bmp(const char *filename,
 491                                unsigned width, unsigned height,
 492                                float *rgba, unsigned stride);
 493 void debug_dump_ubyte_rgba_bmp(const char *filename,
 494                                unsigned width, unsigned height,
 495                                const ubyte *rgba, unsigned stride);
 496 #else
 497 #define debug_dump_image(prefix, format, cpp, width, height, stride, data) ((void)0)
 498 #define debug_dump_surface(pipe, prefix, surface) ((void)0)
 499 #define debug_dump_surface_bmp(pipe, filename, surface) ((void)0)
 500 #define debug_dump_transfer_bmp(filename, transfer, ptr) ((void)0)
 501 #define debug_dump_float_rgba_bmp(filename, width, height, rgba, stride) ((void)0)
 502 #define debug_dump_ubyte_rgba_bmp(filename, width, height, rgba, stride) ((void)0)
 503 #endif
 504
 505
 506 void
 507 debug_print_transfer_flags(const char *msg, unsigned usage);
 508
 509 void
 510 debug_print_bind_flags(const char *msg, unsigned usage);
 511
 512 void
 513 debug_print_usage_enum(const char *msg, unsigned usage);
 514
 515
 516 #ifdef  __cplusplus
 517 }
 518 #endif
 519
 520 #endif /* U_DEBUG_H_ */