mesa: update to the latest u_debug.h

This requires u_string.h to be updated as well.  There is no more string
functions prefixed by util_.  pipe_debug_message is removed as well.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
Reviewed-by: Ryan Neph <ryanneph@google.com>
Acked-by: Gert Wollny <gert.wollny@collabora.com>
macos/master
Chia-I Wu 3 years ago
parent 049ee8ff40
commit 9526a95d47
  1. 1
      config.h.meson
  2. 2
      meson.build
  3. 2
      src/gallium/auxiliary/tgsi/tgsi_dump.c
  4. 20
      src/gallium/auxiliary/util/u_debug_describe.c
  5. 232
      src/gallium/auxiliary/util/u_string.h
  6. 3
      src/gallium/meson.build
  7. 1
      src/mesa/meson.build
  8. 344
      src/mesa/util/u_debug.c
  9. 158
      src/mesa/util/u_debug.h
  10. 131
      src/mesa/util/u_string.h

@ -15,6 +15,7 @@
#mesondefine HAVE_FUNC_ATTRIBUTE_UNUSED #mesondefine HAVE_FUNC_ATTRIBUTE_UNUSED
#mesondefine HAVE_FUNC_ATTRIBUTE_WARN_UNUSED_RESULT #mesondefine HAVE_FUNC_ATTRIBUTE_WARN_UNUSED_RESULT
#mesondefine HAVE_FUNC_ATTRIBUTE_WEAK #mesondefine HAVE_FUNC_ATTRIBUTE_WEAK
#mesondefine HAVE_STRTOK_R
#mesondefine HAVE_TIMESPEC_GET #mesondefine HAVE_TIMESPEC_GET
#mesondefine HAVE_SYS_UIO_H #mesondefine HAVE_SYS_UIO_H
#mesondefine HAVE_PTHREAD #mesondefine HAVE_PTHREAD

@ -143,7 +143,7 @@ foreach a : supported_function_attributes
conf_data.set('HAVE_FUNC_ATTRIBUTE_@0@'.format(a.to_upper()), 1) conf_data.set('HAVE_FUNC_ATTRIBUTE_@0@'.format(a.to_upper()), 1)
endforeach endforeach
foreach f : ['timespec_get'] foreach f : ['strtok_r', 'timespec_get']
if cc.has_function(f) if cc.has_function(f)
conf_data.set('HAVE_@0@'.format(f.to_upper()), 1) conf_data.set('HAVE_@0@'.format(f.to_upper()), 1)
endif endif

@ -734,7 +734,7 @@ str_dump_ctx_printf(struct dump_ctx *ctx, const char *format, ...)
int written; int written;
va_list ap; va_list ap;
va_start(ap, format); va_start(ap, format);
written = util_vsnprintf(sctx->ptr, sctx->left, format, ap); written = vsnprintf(sctx->ptr, sctx->left, format, ap);
va_end(ap); va_end(ap);
/* Some complicated logic needed to handle the return value of /* Some complicated logic needed to handle the return value of

@ -41,25 +41,25 @@ debug_describe_resource(char* buf, const struct pipe_resource *ptr)
switch(ptr->target) switch(ptr->target)
{ {
case PIPE_BUFFER: case PIPE_BUFFER:
util_sprintf(buf, "pipe_buffer<%u>", (unsigned)util_format_get_stride(ptr->format, ptr->width0)); sprintf(buf, "pipe_buffer<%u>", (unsigned)util_format_get_stride(ptr->format, ptr->width0));
break; break;
case PIPE_TEXTURE_1D: case PIPE_TEXTURE_1D:
util_sprintf(buf, "pipe_texture1d<%u,%s,%u>", ptr->width0, util_format_short_name(ptr->format), ptr->last_level); sprintf(buf, "pipe_texture1d<%u,%s,%u>", ptr->width0, util_format_short_name(ptr->format), ptr->last_level);
break; break;
case PIPE_TEXTURE_2D: case PIPE_TEXTURE_2D:
util_sprintf(buf, "pipe_texture2d<%u,%u,%s,%u>", ptr->width0, ptr->height0, util_format_short_name(ptr->format), ptr->last_level); sprintf(buf, "pipe_texture2d<%u,%u,%s,%u>", ptr->width0, ptr->height0, util_format_short_name(ptr->format), ptr->last_level);
break; break;
case PIPE_TEXTURE_RECT: case PIPE_TEXTURE_RECT:
util_sprintf(buf, "pipe_texture_rect<%u,%u,%s>", ptr->width0, ptr->height0, util_format_short_name(ptr->format)); sprintf(buf, "pipe_texture_rect<%u,%u,%s>", ptr->width0, ptr->height0, util_format_short_name(ptr->format));
break; break;
case PIPE_TEXTURE_CUBE: case PIPE_TEXTURE_CUBE:
util_sprintf(buf, "pipe_texture_cube<%u,%u,%s,%u>", ptr->width0, ptr->height0, util_format_short_name(ptr->format), ptr->last_level); sprintf(buf, "pipe_texture_cube<%u,%u,%s,%u>", ptr->width0, ptr->height0, util_format_short_name(ptr->format), ptr->last_level);
break; break;
case PIPE_TEXTURE_3D: case PIPE_TEXTURE_3D:
util_sprintf(buf, "pipe_texture3d<%u,%u,%u,%s,%u>", ptr->width0, ptr->height0, ptr->depth0, util_format_short_name(ptr->format), ptr->last_level); sprintf(buf, "pipe_texture3d<%u,%u,%u,%s,%u>", ptr->width0, ptr->height0, ptr->depth0, util_format_short_name(ptr->format), ptr->last_level);
break; break;
default: default:
util_sprintf(buf, "pipe_martian_resource<%u>", ptr->target); sprintf(buf, "pipe_martian_resource<%u>", ptr->target);
break; break;
} }
} }
@ -69,7 +69,7 @@ debug_describe_surface(char* buf, const struct pipe_surface *ptr)
{ {
char res[128]; char res[128];
debug_describe_resource(res, ptr->texture); debug_describe_resource(res, ptr->texture);
util_sprintf(buf, "pipe_surface<%s,%u,%u,%u>", res, ptr->u.tex.level, ptr->u.tex.first_layer, ptr->u.tex.last_layer); sprintf(buf, "pipe_surface<%s,%u,%u,%u>", res, ptr->u.tex.level, ptr->u.tex.first_layer, ptr->u.tex.last_layer);
} }
void void
@ -77,7 +77,7 @@ debug_describe_sampler_view(char* buf, const struct pipe_sampler_view *ptr)
{ {
char res[128]; char res[128];
debug_describe_resource(res, ptr->texture); debug_describe_resource(res, ptr->texture);
util_sprintf(buf, "pipe_sampler_view<%s,%s>", res, util_format_short_name(ptr->format)); sprintf(buf, "pipe_sampler_view<%s,%s>", res, util_format_short_name(ptr->format));
} }
void void
@ -86,6 +86,6 @@ debug_describe_so_target(char* buf,
{ {
char res[128]; char res[128];
debug_describe_resource(res, ptr->buffer); debug_describe_resource(res, ptr->buffer);
util_sprintf(buf, "pipe_stream_output_target<%s,%u,%u>", res, sprintf(buf, "pipe_stream_output_target<%s,%u,%u>", res,
ptr->buffer_offset, ptr->buffer_size); ptr->buffer_offset, ptr->buffer_size);
} }

@ -1,232 +0,0 @@
/**************************************************************************
*
* Copyright 2008 VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
/**
* @file
* Platform independent functions for string manipulation.
*
* @author Jose Fonseca <jfonseca@vmware.com>
*/
#ifndef U_STRING_H_
#define U_STRING_H_
#if !defined(_MSC_VER) && !defined(XF86_LIBC_H)
#include <stdio.h>
#endif
#include <stddef.h>
#include <stdarg.h>
#include "pipe/p_compiler.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef _GNU_SOURCE
#define util_strchrnul strchrnul
#else
static inline char *
util_strchrnul(const char *s, char c)
{
for (; *s && *s != c; ++s);
return (char *)s;
}
#endif
#ifdef _MSC_VER
int util_vsnprintf(char *, size_t, const char *, va_list);
int util_snprintf(char *str, size_t size, const char *format, ...);
static inline void
util_vsprintf(char *str, const char *format, va_list ap)
{
util_vsnprintf(str, (size_t)-1, format, ap);
}
static inline void
util_sprintf(char *str, const char *format, ...)
{
va_list ap;
va_start(ap, format);
util_vsnprintf(str, (size_t)-1, format, ap);
va_end(ap);
}
static inline char *
util_strchr(const char *s, char c)
{
char *p = util_strchrnul(s, c);
return *p ? p : NULL;
}
static inline char*
util_strncat(char *dst, const char *src, size_t n)
{
char *p = dst + strlen(dst);
const char *q = src;
size_t i;
for (i = 0; i < n && *q != '\0'; ++i)
*p++ = *q++;
*p = '\0';
return dst;
}
static inline int
util_strcmp(const char *s1, const char *s2)
{
unsigned char u1, u2;
while (1) {
u1 = (unsigned char) *s1++;
u2 = (unsigned char) *s2++;
if (u1 != u2)
return u1 - u2;
if (u1 == '\0')
return 0;
}
return 0;
}
static inline int
util_strncmp(const char *s1, const char *s2, size_t n)
{
unsigned char u1, u2;
while (n-- > 0) {
u1 = (unsigned char) *s1++;
u2 = (unsigned char) *s2++;
if (u1 != u2)
return u1 - u2;
if (u1 == '\0')
return 0;
}
return 0;
}
static inline char *
util_strstr(const char *haystack, const char *needle)
{
const char *p = haystack;
size_t len = strlen(needle);
for (; (p = util_strchr(p, *needle)) != 0; p++) {
if (util_strncmp(p, needle, len) == 0) {
return (char *)p;
}
}
return NULL;
}
static inline void *
util_memmove(void *dest, const void *src, size_t n)
{
char *p = (char *)dest;
const char *q = (const char *)src;
if (dest < src) {
while (n--)
*p++ = *q++;
}
else
{
p += n;
q += n;
while (n--)
*--p = *--q;
}
return dest;
}
#else
#define util_vsnprintf vsnprintf
#define util_snprintf snprintf
#define util_vsprintf vsprintf
#define util_sprintf sprintf
#define util_strchr strchr
#define util_strcmp strcmp
#define util_strncmp strncmp
#define util_strncat strncat
#define util_strstr strstr
#define util_memmove memmove
#endif
/**
* Printable string buffer
*/
struct util_strbuf
{
char *str;
char *ptr;
size_t left;
};
static inline void
util_strbuf_init(struct util_strbuf *sbuf, char *str, size_t size)
{
sbuf->str = str;
sbuf->str[0] = 0;
sbuf->ptr = sbuf->str;
sbuf->left = size;
}
static inline void
util_strbuf_printf(struct util_strbuf *sbuf, const char *format, ...)
{
if(sbuf->left > 1) {
size_t written;
va_list ap;
va_start(ap, format);
written = util_vsnprintf(sbuf->ptr, sbuf->left, format, ap);
va_end(ap);
sbuf->ptr += written;
sbuf->left -= written;
}
}
#ifdef __cplusplus
}
#endif
#endif /* U_STRING_H_ */

@ -35,7 +35,6 @@ sources_libgallium = [
'auxiliary/util/u_math.h', 'auxiliary/util/u_math.h',
'auxiliary/util/rgtc.h', 'auxiliary/util/rgtc.h',
'auxiliary/util/u_format.c', 'auxiliary/util/u_format.c',
'auxiliary/util/u_debug.h',
'auxiliary/util/u_inlines.h', 'auxiliary/util/u_inlines.h',
'auxiliary/util/u_texture.c', 'auxiliary/util/u_texture.c',
'auxiliary/util/u_pointer.h', 'auxiliary/util/u_pointer.h',
@ -45,7 +44,6 @@ sources_libgallium = [
'auxiliary/util/u_texture.h', 'auxiliary/util/u_texture.h',
'auxiliary/util/u_hash_table.h', 'auxiliary/util/u_hash_table.h',
'auxiliary/util/u_box.h', 'auxiliary/util/u_box.h',
'auxiliary/util/u_debug.c',
'auxiliary/util/u_cpu_detect.c', 'auxiliary/util/u_cpu_detect.c',
'auxiliary/util/u_pack_color.h', 'auxiliary/util/u_pack_color.h',
'auxiliary/util/u_double_list.h', 'auxiliary/util/u_double_list.h',
@ -54,7 +52,6 @@ sources_libgallium = [
'auxiliary/util/u_cpu_detect.h', 'auxiliary/util/u_cpu_detect.h',
'auxiliary/util/u_bitmask.h', 'auxiliary/util/u_bitmask.h',
'auxiliary/util/u_format_s3tc.h', 'auxiliary/util/u_format_s3tc.h',
'auxiliary/util/u_string.h',
'auxiliary/util/u_surface.c', 'auxiliary/util/u_surface.c',
'auxiliary/util/u_math.c', 'auxiliary/util/u_math.c',
'auxiliary/util/u_half.h', 'auxiliary/util/u_half.h',

@ -6,6 +6,7 @@ inc_mesa = include_directories('.', 'compat', 'pipe', 'util')
files_mesa = files( files_mesa = files(
'util/os_file.c', 'util/os_file.c',
'util/os_misc.c', 'util/os_misc.c',
'util/u_debug.c',
) )
deps_mesa = [ deps_mesa = [

@ -1,9 +1,9 @@
/************************************************************************** /**************************************************************************
* *
* Copyright 2008 VMware, Inc. * Copyright 2008 VMware, Inc.
* Copyright (c) 2008 VMware, Inc. * Copyright (c) 2008 VMware, Inc.
* All Rights Reserved. * All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the * copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including * "Software"), to deal in the Software without restriction, including
@ -11,11 +11,11 @@
* distribute, sub license, and/or sell copies of the Software, and to * distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to * permit persons to whom the Software is furnished to do so, subject to
* the following conditions: * the following conditions:
* *
* The above copyright notice and this permission notice (including the * The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions * next paragraph) shall be included in all copies or substantial portions
* of the Software. * of the Software.
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
@ -23,23 +23,17 @@
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
* *
**************************************************************************/ **************************************************************************/
#include "pipe/p_config.h" /* (virglrenderer) removed includes for p_format.h and p_state.h */
#include "pipe/p_compiler.h" #include "pipe/p_compiler.h"
#include "util/u_debug.h" #include "pipe/p_config.h"
#include "pipe/p_format.h"
#include "pipe/p_state.h" #include "util/u_debug.h"
#include "util/u_inlines.h" #include "util/u_string.h"
#include "util/u_format.h" #include <inttypes.h>
#include "util/u_memory.h"
#include "util/u_string.h"
#include "util/u_math.h"
#include "util/u_prim.h"
#include "util/u_surface.h"
#include <stdio.h> #include <stdio.h>
#include <limits.h> /* CHAR_BIT */ #include <limits.h> /* CHAR_BIT */
@ -51,24 +45,28 @@
#endif #endif
void _debug_vprintf(const char *format, va_list ap) void
_debug_vprintf(const char *format, va_list ap)
{ {
static char buf[4096] = {'\0'}; static char buf[4096] = {'\0'};
#if defined(PIPE_OS_WINDOWS) || defined(PIPE_SUBSYSTEM_EMBEDDED) #if DETECT_OS_WINDOWS || defined(EMBEDDED_DEVICE)
/* We buffer until we find a newline. */ /* We buffer until we find a newline. */
size_t len = strlen(buf); size_t len = strlen(buf);
int ret = util_vsnprintf(buf + len, sizeof(buf) - len, format, ap); int ret = vsnprintf(buf + len, sizeof(buf) - len, format, ap);
if(ret > (int)(sizeof(buf) - len - 1) || util_strchr(buf + len, '\n')) { if (ret > (int)(sizeof(buf) - len - 1) || strchr(buf + len, '\n')) {
os_log_message(buf); os_log_message(buf);
buf[0] = '\0'; buf[0] = '\0';
} }
#else #else
util_vsnprintf(buf, sizeof(buf), format, ap); vsnprintf(buf, sizeof(buf), format, ap);
os_log_message(buf); os_log_message(buf);
#endif #endif
} }
/* (virglrenderer) removed _pipe_debug_message */
void void
debug_disable_error_message_boxes(void) debug_disable_error_message_boxes(void)
{ {
@ -96,9 +94,8 @@ debug_disable_error_message_boxes(void)
#ifdef DEBUG #ifdef DEBUG
void debug_print_blob( const char *name, void
const void *blob, debug_print_blob(const char *name, const void *blob, unsigned size)
unsigned size )
{ {
const unsigned *ublob = (const unsigned *)blob; const unsigned *ublob = (const unsigned *)blob;
unsigned i; unsigned i;
@ -113,11 +110,11 @@ void debug_print_blob( const char *name,
#endif #endif
static boolean static bool
debug_get_option_should_print(void) debug_get_option_should_print(void)
{ {
static boolean first = TRUE; static bool first = true;
static boolean value = FALSE; static bool value = false;
if (!first) if (!first)
return value; return value;
@ -125,55 +122,59 @@ debug_get_option_should_print(void)
/* Oh hey this will call into this function, /* Oh hey this will call into this function,
* but its cool since we set first to false * but its cool since we set first to false
*/ */
first = FALSE; first = false;
value = debug_get_bool_option("GALLIUM_PRINT_OPTIONS", FALSE); value = debug_get_bool_option("GALLIUM_PRINT_OPTIONS", false);
/* XXX should we print this option? Currently it wont */ /* XXX should we print this option? Currently it wont */
return value; return value;
} }
const char * const char *
debug_get_option(const char *name, const char *dfault) debug_get_option(const char *name, const char *dfault)
{ {
const char *result; const char *result;
result = os_get_option(name); result = os_get_option(name);
if(!result) if (!result)
result = dfault; result = dfault;
if (debug_get_option_should_print()) if (debug_get_option_should_print())
debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? result : "(null)"); debug_printf("%s: %s = %s\n", __FUNCTION__, name,
result ? result : "(null)");
return result; return result;
} }
boolean
debug_get_bool_option(const char *name, boolean dfault) bool
debug_get_bool_option(const char *name, bool dfault)
{ {
const char *str = os_get_option(name); const char *str = os_get_option(name);
boolean result; bool result;
if(str == NULL) if (str == NULL)
result = dfault; result = dfault;
else if(!util_strcmp(str, "n")) else if (!strcmp(str, "n"))
result = FALSE; result = false;
else if(!util_strcmp(str, "no")) else if (!strcmp(str, "no"))
result = FALSE; result = false;
else if(!util_strcmp(str, "0")) else if (!strcmp(str, "0"))
result = FALSE; result = false;
else if(!util_strcmp(str, "f")) else if (!strcmp(str, "f"))
result = FALSE; result = false;
else if(!util_strcmp(str, "F")) else if (!strcmp(str, "F"))
result = FALSE; result = false;
else if(!util_strcmp(str, "false")) else if (!strcmp(str, "false"))
result = FALSE; result = false;
else if(!util_strcmp(str, "FALSE")) else if (!strcmp(str, "FALSE"))
result = FALSE; result = false;
else else
result = TRUE; result = true;
if (debug_get_option_should_print()) if (debug_get_option_should_print())
debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? "TRUE" : "FALSE"); debug_printf("%s: %s = %s\n", __FUNCTION__, name,
result ? "TRUE" : "FALSE");
return result; return result;
} }
@ -183,27 +184,18 @@ debug_get_num_option(const char *name, long dfault)
{ {
long result; long result;
const char *str; const char *str;
str = os_get_option(name); str = os_get_option(name);
if(!str) if (!str) {
result = dfault; result = dfault;
else { } else {
long sign; char *endptr;
char c;
c = *str++; result = strtol(str, &endptr, 0);
if(c == '-') { if (str == endptr) {
sign = -1; /* Restore the default value when no digits were found. */
c = *str++; result = dfault;
}
else {
sign = 1;
}
result = 0;
while('0' <= c && c <= '9') {
result = result*10 + (c - '0');
c = *str++;
} }
result *= sign;
} }
if (debug_get_option_should_print()) if (debug_get_option_should_print())
@ -212,16 +204,42 @@ debug_get_num_option(const char *name, long dfault)
return result; return result;
} }
static boolean str_has_option(const char *str, const char *name) void
debug_get_version_option(const char *name, unsigned *major, unsigned *minor)
{
const char *str;
str = os_get_option(name);
if (str) {
unsigned v_maj, v_min;
int n;
n = sscanf(str, "%u.%u", &v_maj, &v_min);
if (n != 2) {
debug_printf("Illegal version specified for %s : %s\n", name, str);
return;
}
*major = v_maj;
*minor = v_min;
}
if (debug_get_option_should_print())
debug_printf("%s: %s = %u.%u\n", __FUNCTION__, name, *major, *minor);
return;
}
static bool
str_has_option(const char *str, const char *name)
{ {
/* Empty string. */ /* Empty string. */
if (!*str) { if (!*str) {
return FALSE; return false;
} }
/* OPTION=all */ /* OPTION=all */
if (!util_strcmp(str, "all")) { if (!strcmp(str, "all")) {
return TRUE; return true;
} }
/* Find 'name' in 'str' surrounded by non-alphanumeric characters. */ /* Find 'name' in 'str' surrounded by non-alphanumeric characters. */
@ -238,11 +256,11 @@ static boolean str_has_option(const char *str, const char *name)
if (!*str || !(isalnum(*str) || *str == '_')) { if (!*str || !(isalnum(*str) || *str == '_')) {
if (str-start == name_len && if (str-start == name_len &&
!memcmp(start, name, name_len)) { !memcmp(start, name, name_len)) {
return TRUE; return true;
} }
if (!*str) { if (!*str) {
return FALSE; return false;
} }
start = str+1; start = str+1;
@ -252,35 +270,36 @@ static boolean str_has_option(const char *str, const char *name)
} }
} }
return FALSE; return false;
} }
unsigned long
debug_get_flags_option(const char *name, uint64_t
debug_get_flags_option(const char *name,
const struct debug_named_value *flags, const struct debug_named_value *flags,
unsigned long dfault) uint64_t dfault)
{ {
unsigned long result; uint64_t result;
const char *str; const char *str;
const struct debug_named_value *orig = flags; const struct debug_named_value *orig = flags;
unsigned namealign = 0; unsigned namealign = 0;
str = os_get_option(name); str = os_get_option(name);
if(!str) if (!str)
result = dfault; result = dfault;
else if (!util_strcmp(str, "help")) { else if (!strcmp(str, "help")) {
result = dfault; result = dfault;
_debug_printf("%s: help for %s:\n", __FUNCTION__, name); _debug_printf("%s: help for %s:\n", __FUNCTION__, name);
for (; flags->name; ++flags) for (; flags->name; ++flags)
namealign = MAX2(namealign, strlen(flags->name)); namealign = MAX2(namealign, strlen(flags->name));
for (flags = orig; flags->name; ++flags) for (flags = orig; flags->name; ++flags)
_debug_printf("| %*s [0x%0*lx]%s%s\n", namealign, flags->name, _debug_printf("| %*s [0x%0*"PRIx64"]%s%s\n", namealign, flags->name,
(int)sizeof(unsigned long)*CHAR_BIT/4, flags->value, (int)sizeof(uint64_t)*CHAR_BIT/4, flags->value,
flags->desc ? " " : "", flags->desc ? flags->desc : ""); flags->desc ? " " : "", flags->desc ? flags->desc : "");
} }
else { else {
result = 0; result = 0;
while( flags->name ) { while (flags->name) {
if (str_has_option(str, flags->name)) if (str_has_option(str, flags->name))
result |= flags->value; result |= flags->value;
++flags; ++flags;
@ -289,9 +308,10 @@ debug_get_flags_option(const char *name,
if (debug_get_option_should_print()) { if (debug_get_option_should_print()) {
if (str) { if (str) {
debug_printf("%s: %s = 0x%lx (%s)\n", __FUNCTION__, name, result, str); debug_printf("%s: %s = 0x%"PRIx64" (%s)\n",
__FUNCTION__, name, result, str);
} else { } else {
debug_printf("%s: %s = 0x%lx\n", __FUNCTION__, name, result); debug_printf("%s: %s = 0x%"PRIx64"\n", __FUNCTION__, name, result);
} }
} }
@ -299,42 +319,42 @@ debug_get_flags_option(const char *name,
} }
void _debug_assert_fail(const char *expr, void
const char *file, _debug_assert_fail(const char *expr, const char *file, unsigned line,
unsigned line, const char *function)
const char *function)
{ {
_debug_printf("%s:%u:%s: Assertion `%s' failed.\n", file, line, function, expr); _debug_printf("%s:%u:%s: Assertion `%s' failed.\n",
file, line, function, expr);
os_abort(); os_abort();
} }
const char * const char *
debug_dump_enum(const struct debug_named_value *names, debug_dump_enum(const struct debug_named_value *names,
unsigned long value) unsigned long value)
{ {
static char rest[64]; static char rest[64];
while(names->name) { while (names->name) {
if(names->value == value) if (names->value == value)
return names->name; return names->name;
++names; ++names;
} }
util_snprintf(rest, sizeof(rest), "0x%08lx", value); snprintf(rest, sizeof(rest), "0x%08lx", value);
return rest; return rest;
} }
const char * const char *
debug_dump_enum_noprefix(const struct debug_named_value *names, debug_dump_enum_noprefix(const struct debug_named_value *names,
const char *prefix, const char *prefix,
unsigned long value) unsigned long value)
{ {
static char rest[64]; static char rest[64];
while(names->name) { while (names->name) {
if(names->value == value) { if (names->value == value) {
const char *name = names->name; const char *name = names->name;
while (*name == *prefix) { while (*name == *prefix) {
name++; name++;
@ -345,16 +365,13 @@ debug_dump_enum_noprefix(const struct debug_named_value *names,
++names; ++names;
} }
snprintf(rest, sizeof(rest), "0x%08lx", value);
util_snprintf(rest, sizeof(rest), "0x%08lx", value);
return rest; return rest;
} }
const char * const char *
debug_dump_flags(const struct debug_named_value *names, debug_dump_flags(const struct debug_named_value *names, unsigned long value)
unsigned long value)
{ {
static char output[4096]; static char output[4096];
static char rest[256]; static char rest[256];
@ -362,70 +379,34 @@ debug_dump_flags(const struct debug_named_value *names,
output[0] = '\0'; output[0] = '\0';
while(names->name) { while (names->name) {
if((names->value & value) == names->value) { if ((names->value & value) == names->value) {
if (!first) if (!first)
util_strncat(output, "|", sizeof(output) - strlen(output) - 1); strncat(output, "|", sizeof(output) - strlen(output) - 1);
else else
first = 0; first = 0;
util_strncat(output, names->name, sizeof(output) - strlen(output) - 1); strncat(output, names->name, sizeof(output) - strlen(output) - 1);
output[sizeof(output) - 1] = '\0'; output[sizeof(output) - 1] = '\0';
value &= ~names->value; value &= ~names->value;
} }
++names; ++names;
} }
if (value) { if (value) {
if (!first) if (!first)
util_strncat(output, "|", sizeof(output) - strlen(output) - 1); strncat(output, "|", sizeof(output) - strlen(output) - 1);
else else
first = 0; first = 0;
util_snprintf(rest, sizeof(rest), "0x%08lx", value); snprintf(rest, sizeof(rest), "0x%08lx", value);
util_strncat(output, rest, sizeof(output) - strlen(output) - 1); strncat(output, rest, sizeof(output) - strlen(output) - 1);
output[sizeof(output) - 1] = '\0'; output[sizeof(output) - 1] = '\0';
} }
if(first)
return "0";
return output;
}
#ifdef DEBUG
void debug_print_format(const char *msg, unsigned fmt )
{
debug_printf("%s: %s\n", msg, util_format_name(fmt));
}
#endif
static const struct debug_named_value pipe_prim_names[] = {
#ifdef DEBUG
DEBUG_NAMED_VALUE(PIPE_PRIM_POINTS),
DEBUG_NAMED_VALUE(PIPE_PRIM_LINES),
DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_LOOP),
DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_STRIP),
DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLES),
DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_STRIP),
DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_FAN),
DEBUG_NAMED_VALUE(PIPE_PRIM_QUADS),
DEBUG_NAMED_VALUE(PIPE_PRIM_QUAD_STRIP),
DEBUG_NAMED_VALUE(PIPE_PRIM_POLYGON),
DEBUG_NAMED_VALUE(PIPE_PRIM_LINES_ADJACENCY),
DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_STRIP_ADJACENCY),
DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLES_ADJACENCY),
DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY),
#endif
DEBUG_NAMED_VALUE_END
};
if (first)
return "0";
const char *u_prim_name( unsigned prim ) return output;
{
return debug_dump_enum(pipe_prim_names, prim);
} }
@ -469,48 +450,3 @@ debug_funclog_enter_exit(const char* f, UNUSED const int line,
debug_printf("%s\n", f); debug_printf("%s\n", f);
} }
#endif #endif
#ifdef DEBUG
/**
* Print PIPE_TRANSFER_x flags with a message.
*/
void
debug_print_transfer_flags(const char *msg, unsigned usage)
{
#define FLAG(x) { x, #x }
static const struct {
unsigned bit;
const char *name;
} flags[] = {
FLAG(PIPE_TRANSFER_READ),
FLAG(PIPE_TRANSFER_WRITE),
FLAG(PIPE_TRANSFER_MAP_DIRECTLY),
FLAG(PIPE_TRANSFER_DISCARD_RANGE),
FLAG(PIPE_TRANSFER_DONTBLOCK),
FLAG(PIPE_TRANSFER_UNSYNCHRONIZED),
FLAG(PIPE_TRANSFER_FLUSH_EXPLICIT),
FLAG(PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE)
};
unsigned i;
debug_printf("%s ", msg);
for (i = 0; i < ARRAY_SIZE(flags); i++) {
if (usage & flags[i].bit) {
debug_printf("%s", flags[i].name);
usage &= ~flags[i].bit;
if (usage) {
debug_printf(" | ");
}
}
}
debug_printf("\n");
#undef FLAG
}
#endif

@ -38,23 +38,28 @@
#ifndef U_DEBUG_H_ #ifndef U_DEBUG_H_
#define U_DEBUG_H_ #define U_DEBUG_H_
#include <stdarg.h>
#include <string.h>
#if !defined(_WIN32)
#include <sys/types.h>
#include <unistd.h>
#endif
#include "util/os_misc.h" #include "util/os_misc.h"
#include "util/detect_os.h"
#include "util/macros.h"
#include "pipe/p_compiler.h" #if DETECT_OS_HAIKU
#include "pipe/p_format.h" /* Haiku provides debug_printf in libroot with OS.h */
#include <OS.h>
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#if defined(__GNUC__) #define _util_printf_format(fmt, list) PRINTFLIKE(fmt, list)
#define _util_printf_format(fmt, list) __attribute__ ((format (printf, fmt, list)))
#else
#define _util_printf_format(fmt, list)
#endif
void _debug_vprintf(const char *format, va_list ap); void _debug_vprintf(const char *format, va_list ap);
@ -78,7 +83,7 @@ _debug_printf(const char *format, ...)
* - avoid outputing large strings (512 bytes is the current maximum length * - avoid outputing large strings (512 bytes is the current maximum length
* that is guaranteed to be printed in all platforms) * that is guaranteed to be printed in all platforms)
*/ */
#if !defined(PIPE_OS_HAIKU) #if !DETECT_OS_HAIKU
static inline void static inline void
debug_printf(const char *format, ...) _util_printf_format(1,2); debug_printf(const char *format, ...) _util_printf_format(1,2);
@ -94,9 +99,6 @@ debug_printf(const char *format, ...)
(void) format; /* silence warning */ (void) format; /* silence warning */
#endif #endif
} }
#else /* is Haiku */
/* Haiku provides debug_printf in libroot with OS.h */
#include <OS.h>
#endif #endif
@ -108,9 +110,9 @@ debug_printf(const char *format, ...)
*/ */
#define debug_printf_once(args) \ #define debug_printf_once(args) \
do { \ do { \
static boolean once = TRUE; \ static bool once = true; \
if (once) { \ if (once) { \
once = FALSE; \ once = false; \
debug_printf args; \ debug_printf args; \
} \ } \
} while (0) } while (0)
@ -129,13 +131,8 @@ debug_printf(const char *format, ...)
* messages. * messages.
*/ */
void debug_print_blob( const char *name, const void *blob, unsigned size ); void debug_print_blob( const char *name, const void *blob, unsigned size );
/* Print a message along with a prettified format string
*/
void debug_print_format(const char *msg, unsigned fmt );
#else #else
#define debug_print_blob(_name, _blob, _size) ((void)0) #define debug_print_blob(_name, _blob, _size) ((void)0)
#define debug_print_format(_msg, _fmt) ((void)0)
#endif #endif
@ -158,6 +155,12 @@ debug_disable_error_message_boxes(void);
#endif /* !DEBUG */ #endif /* !DEBUG */
long
debug_get_num_option(const char *name, long dfault);
void
debug_get_version_option(const char *name, unsigned *major, unsigned *minor);
#ifdef _MSC_VER #ifdef _MSC_VER
__declspec(noreturn) __declspec(noreturn)
#endif #endif
@ -180,7 +183,7 @@ void _debug_assert_fail(const char *expr,
* For non debug builds the assert macro will expand to a no-op, so do not * For non debug builds the assert macro will expand to a no-op, so do not
* call functions with side effects in the assert expression. * call functions with side effects in the assert expression.
*/ */
#ifdef DEBUG #ifndef NDEBUG
#define debug_assert(expr) ((expr) ? (void)0 : _debug_assert_fail(#expr, __FILE__, __LINE__, __FUNCTION__)) #define debug_assert(expr) ((expr) ? (void)0 : _debug_assert_fail(#expr, __FILE__, __LINE__, __FUNCTION__))
#else #else
#define debug_assert(expr) (void)(0 && (expr)) #define debug_assert(expr) (void)(0 && (expr))
@ -236,11 +239,11 @@ void _debug_assert_fail(const char *expr,
#ifdef DEBUG #ifdef DEBUG
#define debug_warn_once(__msg) \ #define debug_warn_once(__msg) \
do { \ do { \
static bool warned = FALSE; \ static bool warned = false; \
if (!warned) { \ if (!warned) { \
_debug_printf("%s:%u:%s: one time warning: %s\n", \ _debug_printf("%s:%u:%s: one time warning: %s\n", \
__FILE__, __LINE__, __FUNCTION__, __msg); \ __FILE__, __LINE__, __FUNCTION__, __msg); \
warned = TRUE; \ warned = true; \
} \ } \
} while (0) } while (0)
#else #else
@ -260,6 +263,11 @@ void _debug_assert_fail(const char *expr,
_debug_printf("error: %s\n", __msg) _debug_printf("error: %s\n", __msg)
#endif #endif
/**
* Output a debug log message to the debug info callback.
* (virglrenderer) Removed.
*/
/** /**
* Used by debug_dump_enum and debug_dump_flags to describe symbols. * Used by debug_dump_enum and debug_dump_flags to describe symbols.
@ -267,7 +275,7 @@ void _debug_assert_fail(const char *expr,
struct debug_named_value struct debug_named_value
{ {
const char *name; const char *name;
unsigned long value; uint64_t value;
const char *desc; const char *desc;
}; };
@ -369,25 +377,71 @@ void debug_funclog_enter_exit(const char* f, const int line, const char* file);
const char * const char *
debug_get_option(const char *name, const char *dfault); debug_get_option(const char *name, const char *dfault);
boolean bool
debug_get_bool_option(const char *name, boolean dfault); debug_get_bool_option(const char *name, bool dfault);
long long
debug_get_num_option(const char *name, long dfault); debug_get_num_option(const char *name, long dfault);
unsigned long uint64_t
debug_get_flags_option(const char *name, debug_get_flags_option(const char *name,
const struct debug_named_value *flags, const struct debug_named_value *flags,
unsigned long dfault); uint64_t dfault);
#define DEBUG_GET_ONCE_OPTION(suffix, name, dfault) \
static const char * \
debug_get_option_ ## suffix (void) \
{ \
static bool first = true; \
static const char * value; \
if (first) { \
first = false; \
value = debug_get_option(name, dfault); \
} \
return value; \
}
static inline bool
__check_suid(void)
{
#if !defined(_WIN32)
if (geteuid() != getuid())
return true;
#endif
return false;
}
/**
* Define a getter for a debug option which specifies a 'FILE *'
* to open, with additional checks for suid executables. Note
* that if the return is not NULL, the caller owns the 'FILE *'
* reference.
*/
#define DEBUG_GET_ONCE_FILE_OPTION(suffix, name, dfault, mode) \
static FILE * \
debug_get_option_ ## suffix (void) \
{ \
static bool first = true; \
static const char * value; \
if (__check_suid()) \
return NULL; \
if (first) { \
first = false; \
value = debug_get_option(name, dfault); \
} \
if (!value) \
return NULL; \
return fopen(value, mode); \
}
#define DEBUG_GET_ONCE_BOOL_OPTION(sufix, name, dfault) \ #define DEBUG_GET_ONCE_BOOL_OPTION(sufix, name, dfault) \
static boolean \ static bool \
debug_get_option_ ## sufix (void) \ debug_get_option_ ## sufix (void) \
{ \ { \
static boolean first = TRUE; \ static bool first = true; \
static boolean value; \ static bool value; \
if (first) { \ if (first) { \
first = FALSE; \ first = false; \
value = debug_get_bool_option(name, dfault); \ value = debug_get_bool_option(name, dfault); \
} \ } \
return value; \ return value; \
@ -397,10 +451,10 @@ debug_get_option_ ## sufix (void) \
static long \ static long \
debug_get_option_ ## sufix (void) \ debug_get_option_ ## sufix (void) \
{ \ { \
static boolean first = TRUE; \ static bool first = true; \
static long value; \ static long value; \
if (first) { \ if (first) { \
first = FALSE; \ first = false; \
value = debug_get_num_option(name, dfault); \ value = debug_get_num_option(name, dfault); \
} \ } \
return value; \ return value; \
@ -410,50 +464,16 @@ debug_get_option_ ## sufix (void) \
static unsigned long \ static unsigned long \
debug_get_option_ ## sufix (void) \ debug_get_option_ ## sufix (void) \
{ \ { \
static boolean first = TRUE; \ static bool first = true; \
static unsigned long value; \ static unsigned long value; \
if (first) { \ if (first) { \
first = FALSE; \ first = false; \
value = debug_get_flags_option(name, flags, dfault); \ value = debug_get_flags_option(name, flags, dfault); \
} \ } \
return value; \ return value; \
} }
unsigned long
debug_memory_begin(void);
void
debug_memory_end(unsigned long beginning);
#ifdef DEBUG
struct pipe_context;
struct pipe_surface;
struct pipe_transfer;
struct pipe_resource;
void debug_dump_image(const char *prefix,
enum pipe_format format, unsigned cpp,
unsigned width, unsigned height,
unsigned stride,
const void *data);
void debug_dump_surface(struct pipe_context *pipe,
const char *prefix,
struct pipe_surface *surface);
void debug_dump_texture(struct pipe_context *pipe,
const char *prefix,
struct pipe_resource *texture);
#else
#define debug_dump_image(prefix, format, cpp, width, height, stride, data) ((void)0)
#define debug_dump_surface(pipe, prefix, surface) ((void)0)
#endif
void
debug_print_transfer_flags(const char *msg, unsigned usage);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

@ -0,0 +1,131 @@
/**************************************************************************
*
* Copyright 2008 VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
/**
* @file
* Platform independent functions for string manipulation.
*
* @author Jose Fonseca <jfonseca@vmware.com>
*/
#ifndef U_STRING_H_
#define U_STRING_H_
#if !defined(XF86_LIBC_H)
#include <stdio.h>
#endif
#include <stdlib.h>
#include <stddef.h>
#include <stdarg.h>
#include <string.h>
#include <limits.h>
#include "util/macros.h" // PRINTFLIKE
#ifdef __cplusplus
extern "C" {
#endif
#if !defined(_GNU_SOURCE) || defined(__APPLE__)
#define strchrnul util_strchrnul
static inline char *
util_strchrnul(const char *s, char c)
{
for (; *s && *s != c; ++s);
return (char *)s;
}
#endif
#ifdef _WIN32
#define sprintf util_sprintf
static inline void
PRINTFLIKE(2, 3)
util_sprintf(char *str, const char *format, ...)
{
va_list ap;
va_start(ap, format);
vsnprintf(str, INT_MAX, format, ap);
va_end(ap);
}
#define vasprintf util_vasprintf
static inline int
util_vasprintf(char **ret, const char *format, va_list ap)
{
va_list ap_copy;
/* Compute length of output string first */
va_copy(ap_copy, ap);
int r = vsnprintf(NULL, 0, format, ap_copy);
va_end(ap_copy);
if (r < 0)
return -1;
*ret = (char *) malloc(r + 1);
if (!*ret)
return -1;
/* Print to buffer */
return vsnprintf(*ret, r + 1, format, ap);
}
#define asprintf util_asprintf
static inline int
util_asprintf(char **str, const char *fmt, ...)
{
int ret;
va_list args;
va_start(args, fmt);
ret = vasprintf(str, fmt, args);
va_end(args);
return ret;
}
#ifndef strcasecmp
#define strcasecmp stricmp
#endif
#define strdup _strdup
#if defined(_WIN32) && !defined(HAVE_STRTOK_R)
#define strtok_r strtok_s
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif /* U_STRING_H_ */
Loading…
Cancel
Save