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       long sign;
 210       char c;
 211       c = *str++;
 212       if (c == '-') {
 213          sign = -1;
 214          c = *str++;
 215       }
 216       else {
 217          sign = 1;
 218       }
 219       result = 0;
 220       while ('0' <= c && c <= '9') {
 221          result = result*10 + (c - '0');
 222          c = *str++;
 223       }
 224       result *= sign;
 225    }
 226
 227    if (debug_get_option_should_print())
 228       debug_printf("%s: %s = %li\n", __FUNCTION__, name, result);
 229
 230    return result;
 231 }
 232
 233
 234 static boolean
 235 str_has_option(const char *str, const char *name)
 236 {
 237    /* Empty string. */
 238    if (!*str) {
 239       return FALSE;
 240    }
 241
 242    /* OPTION=all */
 243    if (!util_strcmp(str, "all")) {
 244       return TRUE;
 245    }
 246
 247    /* Find 'name' in 'str' surrounded by non-alphanumeric characters. */
 248    {
 249       const char *start = str;
 250       unsigned name_len = strlen(name);
 251
 252       /* 'start' is the beginning of the currently-parsed word,
 253        * we increment 'str' each iteration.
 254        * if we find either the end of string or a non-alphanumeric character,
 255        * we compare 'start' up to 'str-1' with 'name'. */
 256
 257       while (1) {
 258          if (!*str || !(isalnum(*str) || *str == '_')) {
 259             if (str-start == name_len &&
 260                 !memcmp(start, name, name_len)) {
 261                return TRUE;
 262             }
 263
 264             if (!*str) {
 265                return FALSE;
 266             }
 267
 268             start = str+1;
 269          }
 270
 271          str++;
 272       }
 273    }
 274
 275    return FALSE;
 276 }
 277
 278
 279 uint64_t
 280 debug_get_flags_option(const char *name,
 281                        const struct debug_named_value *flags,
 282                        uint64_t dfault)
 283 {
 284    uint64_t result;
 285    const char *str;
 286    const struct debug_named_value *orig = flags;
 287    unsigned namealign = 0;
 288
 289    str = os_get_option(name);
 290    if (!str)
 291       result = dfault;
 292    else if (!util_strcmp(str, "help")) {
 293       result = dfault;
 294       _debug_printf("%s: help for %s:\n", __FUNCTION__, name);
 295       for (; flags->name; ++flags)
 296          namealign = MAX2(namealign, strlen(flags->name));
 297       for (flags = orig; flags->name; ++flags)
 298          _debug_printf("| %*s [0x%0*"PRIx64"]%s%s\n", namealign, flags->name,
 299                       (int)sizeof(uint64_t)*CHAR_BIT/4, flags->value,
 300                       flags->desc ? " " : "", flags->desc ? flags->desc : "");
 301    }
 302    else {
 303       result = 0;
 304       while (flags->name) {
 305          if (str_has_option(str, flags->name))
 306             result |= flags->value;
 307          ++flags;
 308       }
 309    }
 310
 311    if (debug_get_option_should_print()) {
 312       if (str) {
 313          debug_printf("%s: %s = 0x%"PRIx64" (%s)\n",
 314                       __FUNCTION__, name, result, str);
 315       } else {
 316          debug_printf("%s: %s = 0x%"PRIx64"\n", __FUNCTION__, name, result);
 317       }
 318    }
 319
 320    return result;
 321 }
 322
 323
 324 void
 325 _debug_assert_fail(const char *expr, const char *file, unsigned line,
 326                    const char *function)
 327 {
 328    _debug_printf("%s:%u:%s: Assertion `%s' failed.\n",
 329                  file, line, function, expr);
 330    os_abort();
 331 }
 332
 333
 334 const char *
 335 debug_dump_enum(const struct debug_named_value *names,
 336                 unsigned long value)
 337 {
 338    static char rest[64];
 339
 340    while (names->name) {
 341       if (names->value == value)
 342          return names->name;
 343       ++names;
 344    }
 345
 346    util_snprintf(rest, sizeof(rest), "0x%08lx", value);
 347    return rest;
 348 }
 349
 350
 351 const char *
 352 debug_dump_enum_noprefix(const struct debug_named_value *names,
 353                          const char *prefix,
 354                          unsigned long value)
 355 {
 356    static char rest[64];
 357
 358    while (names->name) {
 359       if (names->value == value) {
 360          const char *name = names->name;
 361          while (*name == *prefix) {
 362             name++;
 363             prefix++;
 364          }
 365          return name;
 366       }
 367       ++names;
 368    }
 369
 370    util_snprintf(rest, sizeof(rest), "0x%08lx", value);
 371    return rest;
 372 }
 373
 374
 375 const char *
 376 debug_dump_flags(const struct debug_named_value *names, unsigned long value)
 377 {
 378    static char output[4096];
 379    static char rest[256];
 380    int first = 1;
 381
 382    output[0] = '\0';
 383
 384    while (names->name) {
 385       if ((names->value & value) == names->value) {
 386          if (!first)
 387             util_strncat(output, "|", sizeof(output) - strlen(output) - 1);
 388          else
 389             first = 0;
 390          util_strncat(output, names->name, sizeof(output) - strlen(output) - 1);
 391          output[sizeof(output) - 1] = '\0';
 392          value &= ~names->value;
 393       }
 394       ++names;
 395    }
 396
 397    if (value) {
 398       if (!first)
 399          util_strncat(output, "|", sizeof(output) - strlen(output) - 1);
 400       else
 401          first = 0;
 402
 403       util_snprintf(rest, sizeof(rest), "0x%08lx", value);
 404       util_strncat(output, rest, sizeof(output) - strlen(output) - 1);
 405       output[sizeof(output) - 1] = '\0';
 406    }
 407
 408    if (first)
 409       return "0";
 410
 411    return output;
 412 }
 413
 414
 415 #ifdef DEBUG
 416 void
 417 debug_print_format(const char *msg, unsigned fmt )
 418 {
 419    debug_printf("%s: %s\n", msg, util_format_name(fmt));
 420 }
 421 #endif
 422
 423
 424 /** Return string name of given primitive type */
 425 const char *
 426 u_prim_name(unsigned prim)
 427 {
 428    static const struct debug_named_value names[] = {
 429       DEBUG_NAMED_VALUE(PIPE_PRIM_POINTS),
 430       DEBUG_NAMED_VALUE(PIPE_PRIM_LINES),
 431       DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_LOOP),
 432       DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_STRIP),
 433       DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLES),
 434       DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_STRIP),
 435       DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_FAN),
 436       DEBUG_NAMED_VALUE(PIPE_PRIM_QUADS),
 437       DEBUG_NAMED_VALUE(PIPE_PRIM_QUAD_STRIP),
 438       DEBUG_NAMED_VALUE(PIPE_PRIM_POLYGON),
 439       DEBUG_NAMED_VALUE(PIPE_PRIM_LINES_ADJACENCY),
 440       DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_STRIP_ADJACENCY),
 441       DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLES_ADJACENCY),
 442       DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY),
 443       DEBUG_NAMED_VALUE_END
 444    };
 445    return debug_dump_enum(names, prim);
 446 }
 447
 448
 449
 450 #ifdef DEBUG
 451 int fl_indent = 0;
 452 const char* fl_function[1024];
 453
 454 int
 455 debug_funclog_enter(const char* f, const int line, const char* file)
 456 {
 457    int i;
 458
 459    for (i = 0; i < fl_indent; i++)
 460       debug_printf("  ");
 461    debug_printf("%s\n", f);
 462
 463    assert(fl_indent < 1023);
 464    fl_function[fl_indent++] = f;
 465
 466    return 0;
 467 }
 468
 469 void
 470 debug_funclog_exit(const char* f, const int line, const char* file)
 471 {
 472    --fl_indent;
 473    assert(fl_indent >= 0);
 474    assert(fl_function[fl_indent] == f);
 475 }
 476
 477 void
 478 debug_funclog_enter_exit(const char* f, const int line, const char* file)
 479 {
 480    int i;
 481    for (i = 0; i < fl_indent; i++)
 482       debug_printf("  ");
 483    debug_printf("%s\n", f);
 484 }
 485 #endif
 486
 487
 488
 489 #ifdef DEBUG
 490 /**
 491  * Print PIPE_TRANSFER_x flags with a message.
 492  */
 493 void
 494 debug_print_transfer_flags(const char *msg, unsigned usage)
 495 {
 496    static const struct debug_named_value names[] = {
 497       DEBUG_NAMED_VALUE(PIPE_TRANSFER_READ),
 498       DEBUG_NAMED_VALUE(PIPE_TRANSFER_WRITE),
 499       DEBUG_NAMED_VALUE(PIPE_TRANSFER_MAP_DIRECTLY),
 500       DEBUG_NAMED_VALUE(PIPE_TRANSFER_DISCARD_RANGE),
 501       DEBUG_NAMED_VALUE(PIPE_TRANSFER_DONTBLOCK),
 502       DEBUG_NAMED_VALUE(PIPE_TRANSFER_UNSYNCHRONIZED),
 503       DEBUG_NAMED_VALUE(PIPE_TRANSFER_FLUSH_EXPLICIT),
 504       DEBUG_NAMED_VALUE(PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE),
 505       DEBUG_NAMED_VALUE(PIPE_TRANSFER_PERSISTENT),
 506       DEBUG_NAMED_VALUE(PIPE_TRANSFER_COHERENT),
 507       DEBUG_NAMED_VALUE_END
 508    };
 509
 510    debug_printf("%s: %s\n", msg, debug_dump_flags(names, usage));
 511 }
 512
 513
 514 /**
 515  * Print PIPE_BIND_x flags with a message.
 516  */
 517 void
 518 debug_print_bind_flags(const char *msg, unsigned usage)
 519 {
 520    static const struct debug_named_value names[] = {
 521       DEBUG_NAMED_VALUE(PIPE_BIND_DEPTH_STENCIL),
 522       DEBUG_NAMED_VALUE(PIPE_BIND_RENDER_TARGET),
 523       DEBUG_NAMED_VALUE(PIPE_BIND_BLENDABLE),
 524       DEBUG_NAMED_VALUE(PIPE_BIND_SAMPLER_VIEW),
 525       DEBUG_NAMED_VALUE(PIPE_BIND_VERTEX_BUFFER),
 526       DEBUG_NAMED_VALUE(PIPE_BIND_INDEX_BUFFER),
 527       DEBUG_NAMED_VALUE(PIPE_BIND_CONSTANT_BUFFER),
 528       DEBUG_NAMED_VALUE(PIPE_BIND_DISPLAY_TARGET),
 529       DEBUG_NAMED_VALUE(PIPE_BIND_TRANSFER_WRITE),
 530       DEBUG_NAMED_VALUE(PIPE_BIND_TRANSFER_READ),
 531       DEBUG_NAMED_VALUE(PIPE_BIND_STREAM_OUTPUT),
 532       DEBUG_NAMED_VALUE(PIPE_BIND_CURSOR),
 533       DEBUG_NAMED_VALUE(PIPE_BIND_CUSTOM),
 534       DEBUG_NAMED_VALUE(PIPE_BIND_GLOBAL),
 535       DEBUG_NAMED_VALUE(PIPE_BIND_SHADER_BUFFER),
 536       DEBUG_NAMED_VALUE(PIPE_BIND_SHADER_IMAGE),
 537       DEBUG_NAMED_VALUE(PIPE_BIND_COMPUTE_RESOURCE),
 538       DEBUG_NAMED_VALUE(PIPE_BIND_COMMAND_ARGS_BUFFER),
 539       DEBUG_NAMED_VALUE(PIPE_BIND_SCANOUT),
 540       DEBUG_NAMED_VALUE(PIPE_BIND_SHARED),
 541       DEBUG_NAMED_VALUE(PIPE_BIND_LINEAR),
 542       DEBUG_NAMED_VALUE_END
 543    };
 544
 545    debug_printf("%s: %s\n", msg, debug_dump_flags(names, usage));
 546 }
 547
 548
 549 /**
 550  * Print PIPE_USAGE_x enum values with a message.
 551  */
 552 void
 553 debug_print_usage_enum(const char *msg, unsigned usage)
 554 {
 555    static const struct debug_named_value names[] = {
 556       DEBUG_NAMED_VALUE(PIPE_USAGE_DEFAULT),
 557       DEBUG_NAMED_VALUE(PIPE_USAGE_IMMUTABLE),
 558       DEBUG_NAMED_VALUE(PIPE_USAGE_DYNAMIC),
 559       DEBUG_NAMED_VALUE(PIPE_USAGE_STREAM),
 560       DEBUG_NAMED_VALUE(PIPE_USAGE_STAGING),
 561       DEBUG_NAMED_VALUE_END
 562    };
 563
 564    debug_printf("%s: %s\n", msg, debug_dump_enum(names, usage));
 565 }
 566
 567
 568 #endif