src/gallium/auxiliary/util/u_debug.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 VMware, Inc.
   4  * Copyright (c) 2008 VMware, Inc.
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29
  30 #include "pipe/p_config.h"
  31
  32 #include "pipe/p_compiler.h"
  33 #include "util/u_debug.h"
  34 #include "pipe/p_format.h"
  35 #include "pipe/p_state.h"
  36 #include "util/u_inlines.h"
  37 #include "util/u_format.h"
  38 #include "util/u_memory.h"
  39 #include "util/u_string.h"
  40 #include "util/u_math.h"
  41 #include "util/u_prim.h"
  42 #include <inttypes.h>
  43
  44 #include <stdio.h>
  45 #include <limits.h> /* CHAR_BIT */
  46 #include <ctype.h> /* isalnum */
  47
  48 #ifdef _WIN32
  49 #include <windows.h>
  50 #include <stdlib.h>
  51 #endif
  52
  53
  54 void
  55 _debug_vprintf(const char *format, va_list ap)
  56 {
  57    static char buf[4096] = {'\0'};
  58 #if defined(PIPE_OS_WINDOWS) || defined(PIPE_SUBSYSTEM_EMBEDDED)
  59    /* We buffer until we find a newline. */
  60    size_t len = strlen(buf);
  61    int ret = util_vsnprintf(buf + len, sizeof(buf) - len, format, ap);
  62    if (ret > (int)(sizeof(buf) - len - 1) || util_strchr(buf + len, '\n')) {
  63       os_log_message(buf);
  64       buf[0] = '\0';
  65    }
  66 #else
  67    util_vsnprintf(buf, sizeof(buf), format, ap);
  68    os_log_message(buf);
  69 #endif
  70 }
  71
  72
  73 void
  74 _pipe_debug_message(struct pipe_debug_callback *cb,
  75                     unsigned *id,
  76                     enum pipe_debug_type type,
  77                     const char *fmt, ...)
  78 {
  79    va_list args;
  80    va_start(args, fmt);
  81    if (cb && cb->debug_message)
  82       cb->debug_message(cb->data, id, type, fmt, args);
  83    va_end(args);
  84 }
  85
  86
  87 void
  88 debug_disable_error_message_boxes(void)
  89 {
  90 #ifdef _WIN32
  91    /* When Windows' error message boxes are disabled for this process (as is
  92     * typically the case when running tests in an automated fashion) we disable
  93     * CRT message boxes too.
  94     */
  95    UINT uMode = SetErrorMode(0);
  96    SetErrorMode(uMode);
  97    if (uMode & SEM_FAILCRITICALERRORS) {
  98       /* Disable assertion failure message box.
  99        * http://msdn.microsoft.com/en-us/library/sas1dkb2.aspx
 100        */
 101       _set_error_mode(_OUT_TO_STDERR);
 102 #ifdef _MSC_VER
 103       /* Disable abort message box.
 104        * http://msdn.microsoft.com/en-us/library/e631wekh.aspx
 105        */
 106       _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
 107 #endif
 108    }
 109 #endif /* _WIN32 */
 110 }
 111
 112
 113 #ifdef DEBUG
 114 void
 115 debug_print_blob(const char *name, const void *blob, unsigned size)
 116 {
 117    const unsigned *ublob = (const unsigned *)blob;
 118    unsigned i;
 119
 120    debug_printf("%s (%d dwords%s)\n", name, size/4,
 121                 size%4 ? "... plus a few bytes" : "");
 122
 123    for (i = 0; i < size/4; i++) {
 124       debug_printf("%d:\t%08x\n", i, ublob[i]);
 125    }
 126 }
 127 #endif
 128
 129
 130 static boolean
 131 debug_get_option_should_print(void)
 132 {
 133    static boolean first = TRUE;
 134    static boolean value = FALSE;
 135
 136    if (!first)
 137       return value;
 138
 139    /* Oh hey this will call into this function,
 140     * but its cool since we set first to false
 141     */
 142    first = FALSE;
 143    value = debug_get_bool_option("GALLIUM_PRINT_OPTIONS", FALSE);
 144    /* XXX should we print this option? Currently it wont */
 145    return value;
 146 }
 147
 148
 149 const char *
 150 debug_get_option(const char *name, const char *dfault)
 151 {
 152    const char *result;
 153
 154    result = os_get_option(name);
 155    if (!result)
 156       result = dfault;
 157
 158    if (debug_get_option_should_print())
 159       debug_printf("%s: %s = %s\n", __FUNCTION__, name,
 160                    result ? result : "(null)");
 161
 162    return result;
 163 }
 164
 165
 166 boolean
 167 debug_get_bool_option(const char *name, boolean dfault)
 168 {
 169    const char *str = os_get_option(name);
 170    boolean result;
 171
 172    if (str == NULL)
 173       result = dfault;
 174    else if (!util_strcmp(str, "n"))
 175       result = FALSE;
 176    else if (!util_strcmp(str, "no"))
 177       result = FALSE;
 178    else if (!util_strcmp(str, "0"))
 179       result = FALSE;
 180    else if (!util_strcmp(str, "f"))
 181       result = FALSE;
 182    else if (!util_strcmp(str, "F"))
 183       result = FALSE;
 184    else if (!util_strcmp(str, "false"))
 185       result = FALSE;
 186    else if (!util_strcmp(str, "FALSE"))
 187       result = FALSE;
 188    else
 189       result = TRUE;
 190
 191    if (debug_get_option_should_print())
 192       debug_printf("%s: %s = %s\n", __FUNCTION__, name,
 193                    result ? "TRUE" : "FALSE");
 194
 195    return result;
 196 }
 197
 198
 199 long
 200 debug_get_num_option(const char *name, long dfault)
 201 {
 202    long result;
 203    const char *str;
 204
 205    str = os_get_option(name);
 206    if (!str) {
 207       result = dfault;
 208    } else {
 209       char *endptr;
 210
 211       result = strtol(str, &endptr, 0);
 212       if (str == endptr) {
 213          /* Restore the default value when no digits were found. */
 214          result = dfault;
 215       }
 216    }
 217
 218    if (debug_get_option_should_print())
 219       debug_printf("%s: %s = %li\n", __FUNCTION__, name, result);
 220
 221    return result;
 222 }
 223
 224
 225 static boolean
 226 str_has_option(const char *str, const char *name)
 227 {
 228    /* Empty string. */
 229    if (!*str) {
 230       return FALSE;
 231    }
 232
 233    /* OPTION=all */
 234    if (!util_strcmp(str, "all")) {
 235       return TRUE;
 236    }
 237
 238    /* Find 'name' in 'str' surrounded by non-alphanumeric characters. */
 239    {
 240       const char *start = str;
 241       unsigned name_len = strlen(name);
 242
 243       /* 'start' is the beginning of the currently-parsed word,
 244        * we increment 'str' each iteration.
 245        * if we find either the end of string or a non-alphanumeric character,
 246        * we compare 'start' up to 'str-1' with 'name'. */
 247
 248       while (1) {
 249          if (!*str || !(isalnum(*str) || *str == '_')) {
 250             if (str-start == name_len &&
 251                 !memcmp(start, name, name_len)) {
 252                return TRUE;
 253             }
 254
 255             if (!*str) {
 256                return FALSE;
 257             }
 258
 259             start = str+1;
 260          }
 261
 262          str++;
 263       }
 264    }
 265
 266    return FALSE;
 267 }
 268
 269
 270 uint64_t
 271 debug_get_flags_option(const char *name,
 272                        const struct debug_named_value *flags,
 273                        uint64_t dfault)
 274 {
 275    uint64_t result;
 276    const char *str;
 277    const struct debug_named_value *orig = flags;
 278    unsigned namealign = 0;
 279
 280    str = os_get_option(name);
 281    if (!str)
 282       result = dfault;
 283    else if (!util_strcmp(str, "help")) {
 284       result = dfault;
 285       _debug_printf("%s: help for %s:\n", __FUNCTION__, name);
 286       for (; flags->name; ++flags)
 287          namealign = MAX2(namealign, strlen(flags->name));
 288       for (flags = orig; flags->name; ++flags)
 289          _debug_printf("| %*s [0x%0*"PRIx64"]%s%s\n", namealign, flags->name,
 290                       (int)sizeof(uint64_t)*CHAR_BIT/4, flags->value,
 291                       flags->desc ? " " : "", flags->desc ? flags->desc : "");
 292    }
 293    else {
 294       result = 0;
 295       while (flags->name) {
 296          if (str_has_option(str, flags->name))
 297             result |= flags->value;
 298          ++flags;
 299       }
 300    }
 301
 302    if (debug_get_option_should_print()) {
 303       if (str) {
 304          debug_printf("%s: %s = 0x%"PRIx64" (%s)\n",
 305                       __FUNCTION__, name, result, str);
 306       } else {
 307          debug_printf("%s: %s = 0x%"PRIx64"\n", __FUNCTION__, name, result);
 308       }
 309    }
 310
 311    return result;
 312 }
 313
 314
 315 void
 316 _debug_assert_fail(const char *expr, const char *file, unsigned line,
 317                    const char *function)
 318 {
 319    _debug_printf("%s:%u:%s: Assertion `%s' failed.\n",
 320                  file, line, function, expr);
 321    os_abort();
 322 }
 323
 324
 325 const char *
 326 debug_dump_enum(const struct debug_named_value *names,
 327                 unsigned long value)
 328 {
 329    static char rest[64];
 330
 331    while (names->name) {
 332       if (names->value == value)
 333          return names->name;
 334       ++names;
 335    }
 336
 337    util_snprintf(rest, sizeof(rest), "0x%08lx", value);
 338    return rest;
 339 }
 340
 341
 342 const char *
 343 debug_dump_enum_noprefix(const struct debug_named_value *names,
 344                          const char *prefix,
 345                          unsigned long value)
 346 {
 347    static char rest[64];
 348
 349    while (names->name) {
 350       if (names->value == value) {
 351          const char *name = names->name;
 352          while (*name == *prefix) {
 353             name++;
 354             prefix++;
 355          }
 356          return name;
 357       }
 358       ++names;
 359    }
 360
 361    util_snprintf(rest, sizeof(rest), "0x%08lx", value);
 362    return rest;
 363 }
 364
 365
 366 const char *
 367 debug_dump_flags(const struct debug_named_value *names, unsigned long value)
 368 {
 369    static char output[4096];
 370    static char rest[256];
 371    int first = 1;
 372
 373    output[0] = '\0';
 374
 375    while (names->name) {
 376       if ((names->value & value) == names->value) {
 377          if (!first)
 378             util_strncat(output, "|", sizeof(output) - strlen(output) - 1);
 379          else
 380             first = 0;
 381          util_strncat(output, names->name, sizeof(output) - strlen(output) - 1);
 382          output[sizeof(output) - 1] = '\0';
 383          value &= ~names->value;
 384       }
 385       ++names;
 386    }
 387
 388    if (value) {
 389       if (!first)
 390          util_strncat(output, "|", sizeof(output) - strlen(output) - 1);
 391       else
 392          first = 0;
 393
 394       util_snprintf(rest, sizeof(rest), "0x%08lx", value);
 395       util_strncat(output, rest, sizeof(output) - strlen(output) - 1);
 396       output[sizeof(output) - 1] = '\0';
 397    }
 398
 399    if (first)
 400       return "0";
 401
 402    return output;
 403 }
 404
 405
 406 #ifdef DEBUG
 407 void
 408 debug_print_format(const char *msg, unsigned fmt )
 409 {
 410    debug_printf("%s: %s\n", msg, util_format_name(fmt));
 411 }
 412 #endif
 413
 414
 415 /** Return string name of given primitive type */
 416 const char *
 417 u_prim_name(enum pipe_prim_type prim)
 418 {
 419    static const struct debug_named_value names[] = {
 420       DEBUG_NAMED_VALUE(PIPE_PRIM_POINTS),
 421       DEBUG_NAMED_VALUE(PIPE_PRIM_LINES),
 422       DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_LOOP),
 423       DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_STRIP),
 424       DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLES),
 425       DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_STRIP),
 426       DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_FAN),
 427       DEBUG_NAMED_VALUE(PIPE_PRIM_QUADS),
 428       DEBUG_NAMED_VALUE(PIPE_PRIM_QUAD_STRIP),
 429       DEBUG_NAMED_VALUE(PIPE_PRIM_POLYGON),
 430       DEBUG_NAMED_VALUE(PIPE_PRIM_LINES_ADJACENCY),
 431       DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_STRIP_ADJACENCY),
 432       DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLES_ADJACENCY),
 433       DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY),
 434       DEBUG_NAMED_VALUE_END
 435    };
 436    return debug_dump_enum(names, prim);
 437 }
 438
 439
 440
 441 #ifdef DEBUG
 442 int fl_indent = 0;
 443 const char* fl_function[1024];
 444
 445 int
 446 debug_funclog_enter(const char* f, const int line, const char* file)
 447 {
 448    int i;
 449
 450    for (i = 0; i < fl_indent; i++)
 451       debug_printf("  ");
 452    debug_printf("%s\n", f);
 453
 454    assert(fl_indent < 1023);
 455    fl_function[fl_indent++] = f;
 456
 457    return 0;
 458 }
 459
 460 void
 461 debug_funclog_exit(const char* f, const int line, const char* file)
 462 {
 463    --fl_indent;
 464    assert(fl_indent >= 0);
 465    assert(fl_function[fl_indent] == f);
 466 }
 467
 468 void
 469 debug_funclog_enter_exit(const char* f, const int line, const char* file)
 470 {
 471    int i;
 472    for (i = 0; i < fl_indent; i++)
 473       debug_printf("  ");
 474    debug_printf("%s\n", f);
 475 }
 476 #endif
 477
 478
 479
 480 #ifdef DEBUG
 481 /**
 482  * Print PIPE_TRANSFER_x flags with a message.
 483  */
 484 void
 485 debug_print_transfer_flags(const char *msg, unsigned usage)
 486 {
 487    static const struct debug_named_value names[] = {
 488       DEBUG_NAMED_VALUE(PIPE_TRANSFER_READ),
 489       DEBUG_NAMED_VALUE(PIPE_TRANSFER_WRITE),
 490       DEBUG_NAMED_VALUE(PIPE_TRANSFER_MAP_DIRECTLY),
 491       DEBUG_NAMED_VALUE(PIPE_TRANSFER_DISCARD_RANGE),
 492       DEBUG_NAMED_VALUE(PIPE_TRANSFER_DONTBLOCK),
 493       DEBUG_NAMED_VALUE(PIPE_TRANSFER_UNSYNCHRONIZED),
 494       DEBUG_NAMED_VALUE(PIPE_TRANSFER_FLUSH_EXPLICIT),
 495       DEBUG_NAMED_VALUE(PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE),
 496       DEBUG_NAMED_VALUE(PIPE_TRANSFER_PERSISTENT),
 497       DEBUG_NAMED_VALUE(PIPE_TRANSFER_COHERENT),
 498       DEBUG_NAMED_VALUE_END
 499    };
 500
 501    debug_printf("%s: %s\n", msg, debug_dump_flags(names, usage));
 502 }
 503
 504
 505 /**
 506  * Print PIPE_BIND_x flags with a message.
 507  */
 508 void
 509 debug_print_bind_flags(const char *msg, unsigned usage)
 510 {
 511    static const struct debug_named_value names[] = {
 512       DEBUG_NAMED_VALUE(PIPE_BIND_DEPTH_STENCIL),
 513       DEBUG_NAMED_VALUE(PIPE_BIND_RENDER_TARGET),
 514       DEBUG_NAMED_VALUE(PIPE_BIND_BLENDABLE),
 515       DEBUG_NAMED_VALUE(PIPE_BIND_SAMPLER_VIEW),
 516       DEBUG_NAMED_VALUE(PIPE_BIND_VERTEX_BUFFER),
 517       DEBUG_NAMED_VALUE(PIPE_BIND_INDEX_BUFFER),
 518       DEBUG_NAMED_VALUE(PIPE_BIND_CONSTANT_BUFFER),
 519       DEBUG_NAMED_VALUE(PIPE_BIND_DISPLAY_TARGET),
 520       DEBUG_NAMED_VALUE(PIPE_BIND_STREAM_OUTPUT),
 521       DEBUG_NAMED_VALUE(PIPE_BIND_CURSOR),
 522       DEBUG_NAMED_VALUE(PIPE_BIND_CUSTOM),
 523       DEBUG_NAMED_VALUE(PIPE_BIND_GLOBAL),
 524       DEBUG_NAMED_VALUE(PIPE_BIND_SHADER_BUFFER),
 525       DEBUG_NAMED_VALUE(PIPE_BIND_SHADER_IMAGE),
 526       DEBUG_NAMED_VALUE(PIPE_BIND_COMPUTE_RESOURCE),
 527       DEBUG_NAMED_VALUE(PIPE_BIND_COMMAND_ARGS_BUFFER),
 528       DEBUG_NAMED_VALUE(PIPE_BIND_SCANOUT),
 529       DEBUG_NAMED_VALUE(PIPE_BIND_SHARED),
 530       DEBUG_NAMED_VALUE(PIPE_BIND_LINEAR),
 531       DEBUG_NAMED_VALUE_END
 532    };
 533
 534    debug_printf("%s: %s\n", msg, debug_dump_flags(names, usage));
 535 }
 536
 537
 538 /**
 539  * Print PIPE_USAGE_x enum values with a message.
 540  */
 541 void
 542 debug_print_usage_enum(const char *msg, enum pipe_resource_usage usage)
 543 {
 544    static const struct debug_named_value names[] = {
 545       DEBUG_NAMED_VALUE(PIPE_USAGE_DEFAULT),
 546       DEBUG_NAMED_VALUE(PIPE_USAGE_IMMUTABLE),
 547       DEBUG_NAMED_VALUE(PIPE_USAGE_DYNAMIC),
 548       DEBUG_NAMED_VALUE(PIPE_USAGE_STREAM),
 549       DEBUG_NAMED_VALUE(PIPE_USAGE_STAGING),
 550       DEBUG_NAMED_VALUE_END
 551    };
 552
 553    debug_printf("%s: %s\n", msg, debug_dump_enum(names, usage));
 554 }
 555
 556
 557 #endif