debug.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#define DEBUG_C
#include "ctl/ctldef.h"
#include "ctl/debug.h"

static unsigned debug_logmask = ~0u;

static debug_vlog_t pdebug_vlog = vprintf;

ppDebug(static int debug_printf( const char* fmt, ... );)

ppDebug(debug_trace_t debug_trace = debug_printf;)

void debug_log( unsigned mask, const char* fmt, ... )
{
    assertconst(fmt,1);
    assertcodeptr(pdebug_vlog);
    if( (mask & debug_logmask) || 0 == mask )
    {
        va_list args;
        va_start( args, fmt );
        pdebug_vlog( fmt, args );
        fflush(stdout);
    }
}

void debug_vlog( unsigned mask, const char* fmt, va_list args )
{
    if( (mask & debug_logmask) || 0 == mask )
    {
        assertconst(fmt,1);
        assertcodeptr(pdebug_vlog);
        pdebug_vlog( fmt, args );
    }
}

void debug_logalways(const char* fmt, ... )
{
    va_list args;
    va_start( args, fmt );
    assertconst(fmt,1);
    assertcodeptr(pdebug_vlog);
    pdebug_vlog( fmt, args );
}

void debug_vlogalways(const char* fmt, va_list args )
{
    assertconst(fmt,1);
    assertcodeptr(pdebug_vlog);
    pdebug_vlog( fmt, args );
}

void debug_setvlog( debug_vlog_t debug_vlog )
{
    if( NULL == debug_vlog )
    {
        pdebug_vlog = vprintf;
    }
    else
    {
        pdebug_vlog =  debug_vlog;
    }
    assertcodeptr(pdebug_vlog);
}

void debug_setlogmask( unsigned mask )
{
    debug_logmask = mask;
}

unsigned debug_getlogmask(void)
{
    return debug_logmask;
}

void debug_loghex( unsigned mask, const void* ptr, size_t size )
{
    assertconst(ptr,size);
    if( (mask & debug_logmask) || 0 == mask )
    {
        char printable[16];
        const unsigned char* pBuff = (const unsigned char*)ptr;
        size_t curr = 0;
        while( curr < size )
        {
            unsigned ch = *pBuff++;
            if( 0 == (curr & 0xf) )
            {
                debug_logalways( "%08x: ", curr );
            }
            debug_logalways( "%02x ", ch );
            printable[curr&0xf] = isprint(ch) ? ch : '.';
            if( 0xf == (curr++ & 0xf) )
            {
                debug_logalways( " | %16.16s\n", printable );
            }
        }
        /* Leftovers */
        if( 0 != (size & 0xf) )
        {
            for( curr = curr & 0xf; curr < 16; ++curr )
            {
                debug_logalways( "-- " );
                printable[curr] = ' ';
            }
            debug_logalways( " | %16.16s\n", printable );
        }
    }
}


#ifndef NDEBUG

/*
 * Printf to flush stdout every time; trace functions often mean crashes which 
 * could mean output from a recent printf never gets seen while debugging.
 */
static int debug_printf( const char* fmt, ... )
{
    int ret;
    va_list args;
    va_start( args, fmt );
    ret = vprintf( fmt, args );
    fflush(stdout);
    return ret;
}

void debug_settrace( debug_trace_t trace )
{
    debug_trace = NULL == trace ? debug_printf : trace;
    assertcodeptr(debug_trace);
}

/* Define this if you have a really sucky memory problem */
/*#define CTL_DELUXE_POINTER_CHECKS*/

#ifdef WIN32
#include <windows.h>
/*
 * For assertions: Check that a pointer 'looks' writable
 * \param p Pointer to check
 * \param len Length of memory at p to check 
 * \param align What alignment pointer should have, '1' if none
 * \return true if the pointer looks valid (no guarantee it is), false if invalid
 */
int _checkptr( void* p, size_t len, size_t align )
{
    /* See if pointer is NULL or a NULL->mbr */
    if( (size_t)p < 0x10000 )
        return false;
    /* See if pointer is odd-aligned */
    if( 0 != (((size_t)p)%align) )
        return false;
#ifdef CTL_DELUXE_POINTER_CHECKS
    /* See if function would blindly succeed */
    if( 0 == len )
        return true;
    /* VirtualQuery would tell, but 'security' doesn't report certain blocks */
    /* There are articles that state this is 'unsafe', and I'd probably agree
     * except this is for an assertion; we don't try to 'fix' the problem, we 
     * only detect it a little earlier than the middle of the function. */
    return !IsBadWritePtr( p, len );
#else
    return true;
#endif
}
/*
 * For assertions: Check that a pointer 'looks' readable
 * \param p Pointer to check
 * \param len Length of memory at p to check 
 * \param align What alignment pointer should have, '1' if none
 * \return true if the pointer looks valid (no guarantee it is), false if invalid
 */
int _checkconst( const void* p, size_t len, size_t align )
{
    /* See if pointer is NULL or a NULL->mbr */
    if( (size_t)p < 0x10000 )
        return false;
    /* See if pointer is odd-aligned */
    if( 0 != (((size_t)p)%align) )
        return false;
#ifdef CTL_DELUXE_POINTER_CHECKS
    /* See if function would blindly succeed */
    if( 0 == len )
        return true;
    /* VirtualQuery would tell, but 'security' doesn't report certain blocks */
    /* There are articles that state this is 'unsafe', and I'd probably agree
     * except this is for an assertion; we don't try to 'fix' the problem, we 
     * only detect it a little earlier than the middle of the function. */
    return !IsBadReadPtr( p, len );
#else
    return true;
#endif
}
/*
 * For assertions: Check that a function pointer 'looks' executable
 * \param p Pointer to check
 * \param len Length of memory at p to check 
 * \param align What alignment pointer should have, '1' if none
 * \return true if the pointer looks valid (no guarantee it is), false if invalid
 */
int _checkcall( const void* p )
{
    if( (size_t)p < 0x10000 )
        return false;
#ifdef CTL_DELUXE_POINTER_CHECKS
    /* VirtualQuery would tell, but 'security' doesn't report certain blocks */
    /* There are articles that state this is 'unsafe', and I'd probably agree
     * except this is for an assertion; we don't try to 'fix' the problem, we 
     * only detect it a little earlier than the middle of the function. */
    return !IsBadCodePtr((FARPROC)(p));
#else
    return true;
#endif
}
/*
 * Return non-zero if debugger is attached
 */
int _isdebugging(void)
{
    return false;//IsDebuggerPresent();
}
#else /* not WIN32 */

#include <setjmp.h>
#include <signal.h>
// globals
jmp_buf g_pBuf;
void segv_handler( int nSig)
{
    longjmp( g_pBuf, 1 );
}
  
int _checkptr( void* p, size_t len, size_t align )
{
    /* See if pointer is NULL or a NULL->mbr */
    if( (size_t)p < 0x10000 )
        return false;
    /* See if pointer is odd-aligned */
    if( 0 != (((size_t)p)%align) )
        return false;
#ifdef CTL_DELUXE_POINTER_CHECKS
    /* See if function would blindly succeed */
    if( 0 != len )
    {
        /* 
         * This brute-force approach is unsafe, especially in a multithreaded 
         * environment where a crash in a different thread could jump right into 
         * the middle of this test.  ALSO, this is obscenely time-consuming.  
         */
        void (*sigprev)( int sig);
        if(setjmp(g_pBuf))
        {   /* Something 'bad' happened */
            signal( SIGSEGV, sigprev );
            return false;
        }
        sigprev = signal( SIGSEGV, segv_handler );
        {   /* Non-destructively write all the locations */
            uint8* ptr = (uint8*)p;
            uint32* dwptr;
            uint8* end = ptr + len;
            /* Optimization might spot that ^= 0 is an elaborate NOP but this is 
             * for a DEBUGGING build, not release mode build. */
            /* Align to dw boundary */
            while( ((size_t)p & 3) && ptr < end )
                *ptr++ ^= 0;
            /* Scan 32 bits at a time */
            dwptr = (uint32*)ptr;
            while( dwptr < (uint32*)end )
                *dwptr++ ^= 0;
            /* Finish off any leftovers */
            ptr = (uint8*)dwptr;
            while( ptr < end )
                *ptr++ ^= 0;
        }
        signal( SIGSEGV, sigprev );
    }
#endif
    return true;
}
int _checkconst( const void* p, size_t len, size_t align )
{
    /* See if pointer is NULL or a NULL->mbr */
    if( (size_t)p < 0x10000 )
        return false;
    /* See if pointer is odd-aligned */
    if( 0 != (((size_t)p)%align) )
        return false;
#ifdef CTL_DELUXE_POINTER_CHECKS
    /* See if function would blindly succeed */
    if( 0 != len )
    {
        /* 
         * This brute-force approach is unsafe, especially in a multithreaded 
         * environment where a crash in a different thread could jump right into 
         * the middle of this test.  ALSO, this is obscenely time-consuming.  
         */
        void (*sigprev)( int sig);
        if(setjmp ( g_pBuf))
        {   /* Something 'bad' happened */
            signal( SIGSEGV, sigprev );
            return false;
        }
        sigprev = signal( SIGSEGV, segv_handler );
        {   /* Read all the locations */
            const uint8* ptr = (const uint8*)p;
            const uint32* dwptr;
            const uint8* end = ptr + len;
            /* Brilliant optimization might spot that tmp is unused, 
             * but this is for a DEBUGGING build, not release mode build */
            uint8 tmp = 0;  
            /* Align to dw boundary */
            while( ((size_t)p & 3) && ptr < end )
                tmp += *ptr++;
            /* Scan 32 bits at a time */
            dwptr = (uint32*)ptr;
            while( dwptr < (const uint32*)end )
                tmp += *dwptr++;
            /* Finish off any leftovers */
            ptr = (const uint8*)dwptr;
            while( ptr < end )
                tmp += *ptr++;
        }
        signal( SIGSEGV, sigprev );
    }
#endif
    return true;
}
int _checkcall( const void* p )
{
    return (size_t)p > 0x10000;
}
int _isdebugging(void)
{
    return false;
}

#endif /*WIN32*/

#endif /* DEBUG */