debug.h

Go to the documentation of this file.

#ifndef BERTOS_DEBUG_H
#define BERTOS_DEBUG_H

#include <cfg/os.h>
#include <cfg/compiler.h>

#include "cfg/cfg_debug.h"   /* CONFIG_KDEBUG_* */

/*
 * Defaults for rarely used config stuff.
 */
#ifndef CONFIG_KDEBUG_TRACE
#define CONFIG_KDEBUG_TRACE  1
#endif

#ifndef CONFIG_KDEBUG_VERBOSE_ASSERT
#define CONFIG_KDEBUG_VERBOSE_ASSERT  1
#endif

#ifndef CONFIG_KDEBUG_WALLS
#define CONFIG_KDEBUG_WALLS  1
#endif

#if defined(__doxygen__)

    #define _DEBUG 1
#endif

#ifdef _DEBUG
    // STLport specific: enable extra checks
    #define __STL_DEBUG 1

    // MSVC specific: Enable memory allocation debug
    #if defined(_MSC_VER)
        #include <crtdbg.h>
    #endif

    /*
     * On UNIX systems the extabilished practice is to define
     * NDEBUG for release builds and nothing for debug builds.
     */
    #ifdef NDEBUG
    #undef NDEBUG
    #endif

    #ifndef THIS_FILE
        #define THIS_FILE  __FILE__
    #endif

    #define DB(x) x

    #include <cpu/attr.h>        /* CPU_HARVARD */

    /* These are implemented in drv/kdebug.c */
    void kdbg_init(void);
    void kputchar(char c);
    int kputnum(int num);
    void kdump(const void *buf, size_t len);
    void __init_wall(long *wall, int size);

    #if CPU_HARVARD
        #include <cpu/pgm.h>
        void kputs_P(const char *PROGMEM str);
        void kprintf_P(const char *PROGMEM fmt, ...) FORMAT(__printf__, 1, 2);
        int __bassert_P(const char *PROGMEM cond, const char *PROGMEM file, int line);
        void __trace_P(const char *func);
        void __tracemsg_P(const char *func, const char *PROGMEM fmt, ...);
        int __invalid_ptr_P(void *p, const char *PROGMEM name, const char *PROGMEM file, int line);
        int __check_wall_P(long *wall, int size, const char * PGM_ATTR name, const char * PGM_ATTR file, int line);
        #define kputs(str)  kputs_P(PSTR(str))
        #define kprintf(fmt, ...)  kprintf_P(PSTR(fmt) ,## __VA_ARGS__)
        #define __bassert(cond, file, line)  __bassert_P(PSTR(cond), PSTR(file), (line))
        #define __trace(func)  __trace_P(func)
        #define __tracemsg(func, fmt, ...)  __tracemsg_P(func, PSTR(fmt), ## __VA_ARGS__)
        #define __invalid_ptr(p, name, file, line)  __invalid_ptr_P((p), PSTR(name), PSTR(file), (line))
        #define __check_wall(wall, size, name, file, line)  __check_wall_P(wall, size, PSTR(name), PSTR(file), (line))
    #else /* !CPU_HARVARD */
        void kputs(const char *str);
        void kprintf(const char *fmt, ...) FORMAT(__printf__, 1, 2);
        int __bassert(const char *cond, const char *file, int line);
        void __trace(const char *func);
        void __tracemsg(const char *func, const char *fmt, ...) FORMAT(__printf__, 2, 3);
        int __invalid_ptr(void *p, const char *name, const char *file, int line);
        int __check_wall(long *wall, int size, const char *name, const char *file, int line);
    #endif /* !CPU_HARVARD */

    #if CONFIG_KDEBUG_VERBOSE_ASSERT

        #define ASSERT(x)         ((void)(LIKELY(x) ? 0 : __bassert(#x, THIS_FILE, __LINE__)))

        #define ASSERT2(x, help)  ((void)(LIKELY(x) ? 0 : __bassert(help " (" #x ")", THIS_FILE, __LINE__)))
    #else
        #define ASSERT(x)         ((void)(LIKELY(x) ? 0 : __bassert("", THIS_FILE, __LINE__)))
        #define ASSERT2(x, help)  ((void)ASSERT(x))
    #endif

    #define IS_VALID_PTR(p) (LIKELY((void *)(p) >= (void *)CPU_RAM_START))

    #define ASSERT_VALID_PTR(p) (IS_VALID_PTR(p) \
        ? 0 : __invalid_ptr(p, #p, THIS_FILE, __LINE__))

    #define ASSERT_VALID_PTR_OR_NULL(p) ((void)(LIKELY((p == NULL) \
        || ((void *)(p) >= (void *)CPU_RAM_START)) \
        ? 0 : __invalid_ptr((p), #p, THIS_FILE, __LINE__)))

    #if CONFIG_KDEBUG_TRACE
        #define TRACE  __trace(__func__)
        #define TRACEMSG(msg,...) __tracemsg(__func__, msg, ## __VA_ARGS__)
    #else
        #define TRACE  do {} while(0)
        #define TRACEMSG(...)  do {} while(0)
    #endif

    #define ASSERT_VALID_OBJ(_t, _o) do { \
        ASSERT_VALID_PTR((_o)); \
        ASSERT(dynamic_cast<_t>((_o)) != NULL); \
    }

    #define NEW_INSTANCE(CLASS)                do { ++CLASS::__instances } while (0)
    #define DELETE_INSTANCE(CLASS)             do { --CLASS::__instances } while (0)
    #define ASSERT_ZERO_INSTANCES(CLASS)       ASSERT(CLASS::__instances == 0)
    #define GET_INSTANCE_COUNT(CLASS)          (CLASS::__instances)
    #define DECLARE_INSTANCE_TRACKING(CLASS)   static int __instances
    #define IMPLEMENT_INSTANCE_TRACKING(CLASS) int CLASS::__instances = 0
    /*\}*/

#else /* !_DEBUG */

    /*
     * On UNIX systems the extabilished practice is to define
     * NDEBUG for release builds and nothing for debug builds.
     */
    #ifndef NDEBUG
    #define NDEBUG 1
    #endif

    #define DB(x)  /* nothing */
    #ifndef ASSERT
        #define ASSERT(x)  ((void)0)
    #endif /* ASSERT */
    #define ASSERT2(x, help)             ((void)0)
    #define IS_VALID_PTR(p)              (1)
    #define ASSERT_VALID_PTR(p)          ((void)0)
    #define ASSERT_VALID_PTR_OR_NULL(p)  ((void)0)
    #define ASSERT_VALID_OBJ(_t, _o)     ((void)0)
    #define TRACE                        do {} while (0)
    #if COMPILER_VARIADIC_MACROS
        #define TRACEMSG(x, ...)         do {} while (0)
    #else
        INLINE void TRACEMSG(UNUSED_ARG(const char *, msg), ...)
        {
            /* NOP */
        }
    #endif

    #define NEW_INSTANCE(CLASS)                do {} while (0)
    #define DELETE_INSTANCE(CLASS)             do {} while (0)
    #define ASSERT_ZERO_INSTANCES(CLASS)       do {} while (0)
    #define GET_INSTANCE_COUNT(CLASS)          ERROR_ONLY_FOR_DEBUG
    #define DECLARE_INSTANCE_TRACKING(CLASS)
    #define IMPLEMENT_INSTANCE_TRACKING(CLASS)

    INLINE void kdbg_init(void) { /* nop */ }
    INLINE void kputchar(UNUSED_ARG(char, c)) { /* nop */ }
    INLINE int kputnum(UNUSED_ARG(int, num)) { return 0; }
    INLINE void kputs(UNUSED_ARG(const char *, str)) { /* nop */ }
    INLINE void kdump(UNUSED_ARG(const void *, buf), UNUSED_ARG(size_t, len)) { /* nop */ }

    #if defined(__cplusplus) && COMPILER_VARIADIC_MACROS
        /* G++ can't inline functions with variable arguments... */
        #define kprintf(fmt,...) do { (void)(fmt); } while(0)
    #else
        /* ...but GCC can. */
        INLINE void kprintf(UNUSED_ARG(const char *, fmt), ...) { /* nop */ }
    #endif

#endif /* _DEBUG */

#if CONFIG_KDEBUG_WALLS

    #define WALL_SIZE                    8
    #define WALL_VALUE                   (long)0xABADCAFEL
    #define DECLARE_WALL(name,size)      long name[(size) / sizeof(long)];
    #define FWD_DECLARE_WALL(name,size)  extern long name[(size) / sizeof(long)];
    #define INIT_WALL(name)              __init_wall((name), countof(name))
    #define CHECK_WALL(name)             __check_wall((name), countof(name), #name, THIS_FILE, __LINE__)
    /*\}*/
#else
    #define DECLARE_WALL(name, size)     /* nothing */
    #define FWD_DECLARE_WALL(name, size) /* nothing */
    #define INIT_WALL(name)              do {} while (0)
    #define CHECK_WALL(name)             do {} while (0)
#endif
 // defgroup debug

#endif /* BERTOS_DEBUG_H */