utilities.h File Reference

#include <stdbool.h>
#include <stdint.h>
#include <string.h>

Go to the source code of this file.

Macros
#define	OPENAMP_TO_U64_SAFE(value, out)
#define	OPENAMP_ADD_U64_SAFE(a, b, out)
#define	OPENAMP_SUB_U64_SAFE(a, b, out)
#define	OPENAMP_MUL_U64_SAFE(a, b, out)
#define	OPENAMP_ADD_SAFE(a, b, out)
#define	OPENAMP_SUB_SAFE(a, b, out)
#define	OPENAMP_MUL_SAFE(a, b, out)
#define	OPENAMP_RANGE_CONTAINS(base, base_len, offset, len, contained)

Functions
size_t	safe_strcpy (char *dst, size_t d_size, const char *src, size_t s_size)

Macro Definition Documentation

OPENAMP_ADD_SAFE

#define OPENAMP_ADD_SAFE	(		a,
			b,
			out )

Value:

        (__extension__({ \
        __typeof__(out) __openamp_out = (out); \
        uint64_t __openamp_a; \
        uint64_t __openamp_b; \
        int __openamp_overflow = !__openamp_out || \
                OPENAMP_TO_U64_SAFE((a), &__openamp_a) || \
                OPENAMP_TO_U64_SAFE((b), &__openamp_b); \
        if (!__openamp_overflow) \
                __openamp_overflow = OPENAMP_ADD_U64_SAFE( \
                        __openamp_a, __openamp_b, __openamp_out); \
        __openamp_overflow; \
}))

OPENAMP_ADD_U64_SAFE

#define OPENAMP_ADD_U64_SAFE	(		a,
			b,
			out )

Value:

        (__extension__({ \
        __typeof__(out) __openamp_out = (out); \
        __typeof__(a) __openamp_a = (a); \
        __typeof__(b) __openamp_b = (b); \
        uint64_t __openamp_umax = (uint64_t)(__typeof__(*__openamp_out)) \
                ~(__typeof__(*__openamp_out))0; \
        int __openamp_overflow = __openamp_a > __openamp_umax || \
                __openamp_b > __openamp_umax - __openamp_a; \
        if (!__openamp_overflow) \
                *__openamp_out = (__typeof__(*__openamp_out)) \
                        (__openamp_a + __openamp_b); \
        __openamp_overflow; \
}))

OPENAMP_MUL_SAFE

#define OPENAMP_MUL_SAFE	(		a,
			b,
			out )

Value:

        (__extension__({ \
        __typeof__(out) __openamp_out = (out); \
        uint64_t __openamp_a; \
        uint64_t __openamp_b; \
        int __openamp_overflow = !__openamp_out || \
                OPENAMP_TO_U64_SAFE((a), &__openamp_a) || \
                OPENAMP_TO_U64_SAFE((b), &__openamp_b); \
        if (!__openamp_overflow) \
                __openamp_overflow = OPENAMP_MUL_U64_SAFE( \
                        __openamp_a, __openamp_b, __openamp_out); \
        __openamp_overflow; \
}))

OPENAMP_MUL_U64_SAFE

#define OPENAMP_MUL_U64_SAFE	(		a,
			b,
			out )

Value:

        (__extension__({ \
        __typeof__(out) __openamp_out = (out); \
        __typeof__(a) __openamp_a = (a); \
        __typeof__(b) __openamp_b = (b); \
        uint64_t __openamp_umax = (uint64_t)(__typeof__(*__openamp_out)) \
                ~(__typeof__(*__openamp_out))0; \
        int __openamp_overflow = __openamp_a != 0 && \
                __openamp_b > __openamp_umax / __openamp_a; \
        if (!__openamp_overflow) \
                *__openamp_out = (__typeof__(*__openamp_out)) \
                        (__openamp_a * __openamp_b); \
        __openamp_overflow; \
}))

OPENAMP_RANGE_CONTAINS

#define OPENAMP_RANGE_CONTAINS	(		base,
			base_len,
			offset,
			len,
			contained )

Value:

        (__extension__({ \
                __typeof__(contained) __openamp_contained = (contained); \
                __typeof__(base) __openamp_base = (base); \
                __typeof__(base_len) __openamp_base_len = (base_len); \
                __typeof__(offset) __openamp_offset = (offset); \
                __typeof__(len) __openamp_len = (len); \
                size_t __openamp_base_end; \
                size_t __openamp_end; \
                int __openamp_range_overflow = !__openamp_contained || \
                        OPENAMP_ADD_SAFE(__openamp_base, __openamp_base_len, \
                                         &__openamp_base_end) || \
                        OPENAMP_ADD_SAFE(__openamp_offset, __openamp_len, \
                                         &__openamp_end); \
                if (!__openamp_range_overflow) \
                        *__openamp_contained = __openamp_base <= __openamp_offset && \
                                __openamp_base_end >= __openamp_end; \
                __openamp_range_overflow; \
        }))

OPENAMP_SUB_SAFE

#define OPENAMP_SUB_SAFE	(		a,
			b,
			out )

Value:

        (__extension__({ \
        __typeof__(out) __openamp_out = (out); \
        uint64_t __openamp_a; \
        uint64_t __openamp_b; \
        int __openamp_overflow = !__openamp_out || \
                OPENAMP_TO_U64_SAFE((a), &__openamp_a) || \
                OPENAMP_TO_U64_SAFE((b), &__openamp_b); \
        if (!__openamp_overflow) \
                __openamp_overflow = OPENAMP_SUB_U64_SAFE( \
                        __openamp_a, __openamp_b, __openamp_out); \
        __openamp_overflow; \
}))

OPENAMP_SUB_U64_SAFE

#define OPENAMP_SUB_U64_SAFE	(		a,
			b,
			out )

Value:

        (__extension__({ \
        __typeof__(out) __openamp_out = (out); \
        __typeof__(a) __openamp_a = (a); \
        __typeof__(b) __openamp_b = (b); \
        uint64_t __openamp_umax = (uint64_t)(__typeof__(*__openamp_out)) \
                ~(__typeof__(*__openamp_out))0; \
        int __openamp_overflow = __openamp_a > __openamp_umax || \
                __openamp_b > __openamp_umax || __openamp_a < __openamp_b; \
        if (!__openamp_overflow) \
                *__openamp_out = (__typeof__(*__openamp_out)) \
                        (__openamp_a - __openamp_b); \
        __openamp_overflow; \
}))

OPENAMP_TO_U64_SAFE

#define OPENAMP_TO_U64_SAFE	(		value,
			out )

Value:

        (__extension__({ \
        __typeof__(value) __openamp_value = (value); \
        int __openamp_overflow = 1; \
        if (__openamp_value == 0 || __openamp_value > 0) { \
                *(out) = (uint64_t)__openamp_value; \
                __openamp_overflow = 0; \
        } \
        __openamp_overflow; \
}))

Function Documentation

safe_strcpy()

size_t safe_strcpy	(	char *	dst,
		size_t	d_size,
		const char *	src,
		size_t	s_size )