stdlib.h File Reference

#include <uacpi/internal/types.h>
#include <uacpi/internal/helpers.h>
#include <uacpi/platform/libc.h>
#include <uacpi/platform/config.h>
#include <uacpi/kernel_api.h>

Include dependency graph for stdlib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	uacpi_memcpy   memcpy
#define	uacpi_memmove   memmove
#define	uacpi_memset   memset
#define	uacpi_memcmp   memcmp
#define	uacpi_free(mem, _)   uacpi_kernel_free(mem)
#define	uacpi_memzero(ptr, size)   uacpi_memset(ptr, 0, size)
#define	UACPI_COMPARE(x, y, op)   ((x) op (y) ? (x) : (y))
#define	UACPI_MIN(x, y)   UACPI_COMPARE(x, y, <)
#define	UACPI_MAX(x, y)   UACPI_COMPARE(x, y, >)
#define	UACPI_ALIGN_UP_MASK(x, mask)   (((x) + (mask)) & ~(mask))
#define	UACPI_ALIGN_UP(x, val, type)   UACPI_ALIGN_UP_MASK(x, (type)(val) - 1)
#define	UACPI_ALIGN_DOWN_MASK(x, mask)   ((x) & ~(mask))
#define	UACPI_ALIGN_DOWN(x, val, type)   UACPI_ALIGN_DOWN_MASK(x, (type)(val) - 1)
#define	UACPI_IS_ALIGNED_MASK(x, mask)   (((x) & (mask)) == 0)
#define	UACPI_IS_ALIGNED(x, val, type)   UACPI_IS_ALIGNED_MASK(x, (type)(val) - 1)
#define	UACPI_IS_POWER_OF_TWO(x, type)   UACPI_IS_ALIGNED(x, x, type)
#define	uacpi_kernel_alloc_zeroed   uacpi_builtin_alloc_zeroed

Functions
void *	memcpy (void *dest, const void *src, uacpi_size count)
void *	memmove (void *dest, const void *src, uacpi_size count)
void *	memset (void *dest, int ch, uacpi_size count)
int	memcmp (const void *lhs, const void *rhs, uacpi_size count)
uacpi_size	uacpi_strlen (const uacpi_char *str)
uacpi_size	uacpi_strnlen (const uacpi_char *str, uacpi_size max)
uacpi_i32	uacpi_strcmp (const uacpi_char *lhs, const uacpi_char *rhs)
uacpi_i32	uacpi_snprintf (uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt,...)
uacpi_i32	uacpi_vsnprintf (uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt, uacpi_va_list vlist)
void	uacpi_memcpy_zerout (void *dst, const void *src, uacpi_size dst_size, uacpi_size src_size)
uacpi_u8	uacpi_bit_scan_forward (uacpi_u64)
uacpi_u8	uacpi_bit_scan_backward (uacpi_u64)
void *	uacpi_builtin_alloc_zeroed (uacpi_size size)

Macro Definition Documentation

UACPI_ALIGN_DOWN

#define UACPI_ALIGN_DOWN	(		x,
			val,
			type
	)		UACPI_ALIGN_DOWN_MASK(x, (type)(val) - 1)

Definition at line 109 of file stdlib.h.

UACPI_ALIGN_DOWN_MASK

#define UACPI_ALIGN_DOWN_MASK	(		x,
			mask
	)		((x) & ~(mask))

Definition at line 108 of file stdlib.h.

UACPI_ALIGN_UP

#define UACPI_ALIGN_UP	(		x,
			val,
			type
	)		UACPI_ALIGN_UP_MASK(x, (type)(val) - 1)

Definition at line 106 of file stdlib.h.

UACPI_ALIGN_UP_MASK

#define UACPI_ALIGN_UP_MASK	(		x,
			mask
	)		(((x) + (mask)) & ~(mask))

Definition at line 105 of file stdlib.h.

UACPI_COMPARE

#define UACPI_COMPARE	(		x,
			y,
			op
	)		((x) op (y) ? (x) : (y))

Definition at line 101 of file stdlib.h.

uacpi_free

#define uacpi_free	(		mem,
			_
	)		uacpi_kernel_free(mem)

Definition at line 96 of file stdlib.h.

UACPI_IS_ALIGNED

#define UACPI_IS_ALIGNED	(		x,
			val,
			type
	)		UACPI_IS_ALIGNED_MASK(x, (type)(val) - 1)

Definition at line 112 of file stdlib.h.

UACPI_IS_ALIGNED_MASK

#define UACPI_IS_ALIGNED_MASK	(		x,
			mask
	)		(((x) & (mask)) == 0)

Definition at line 111 of file stdlib.h.

UACPI_IS_POWER_OF_TWO

#define UACPI_IS_POWER_OF_TWO	(		x,
			type
	)		UACPI_IS_ALIGNED(x, x, type)

Definition at line 114 of file stdlib.h.

uacpi_kernel_alloc_zeroed

#define uacpi_kernel_alloc_zeroed   uacpi_builtin_alloc_zeroed

Definition at line 127 of file stdlib.h.

UACPI_MAX

#define UACPI_MAX	(		x,
			y
	)		UACPI_COMPARE(x, y, >)

Definition at line 103 of file stdlib.h.

uacpi_memcmp

#define uacpi_memcmp   memcmp

Definition at line 61 of file stdlib.h.

uacpi_memcpy

#define uacpi_memcpy   memcpy

Definition at line 34 of file stdlib.h.

uacpi_memmove

#define uacpi_memmove   memmove

Definition at line 43 of file stdlib.h.

uacpi_memset

#define uacpi_memset   memset

Definition at line 52 of file stdlib.h.

uacpi_memzero

#define uacpi_memzero	(		ptr,
			size
	)		uacpi_memset(ptr, 0, size)

Definition at line 99 of file stdlib.h.

UACPI_MIN

#define UACPI_MIN	(		x,
			y
	)		UACPI_COMPARE(x, y, <)

Definition at line 102 of file stdlib.h.

Function Documentation

memcmp()

int memcmp	(	const void *	lhs,
		const void *	rhs,
		uacpi_size	count
	)

Definition at line 2802 of file string.c.

{
    const unsigned char *p1 = ptr1, *p2 = ptr2;
    size_t align;
    int result;
 
    if (n < sizeof(uint64_t))
        return memcmp_bytes(p1, p2, n);
 
    align = -(size_t)p1 & (sizeof(uint64_t) - 1);
 
    if ((result = memcmp_bytes(p1, p2, align)))
        return result;
 
    p1 += align;
    p2 += align;
    n  -= align;
 
    return memcmp_blocks(p1, p2, n);
}

memcpy()

void * memcpy	(	void *	dest,
		const void *	src,
		uacpi_size	count
	)

Definition at line 3197 of file string.c.

{
    return memmove(dst, src, n);
}

memmove()

void * memmove	(	void *	dest,
		const void *	src,
		uacpi_size	count
	)

Definition at line 3088 of file string.c.

{
#if defined(__x86_64__) && !defined(__arm64ec__)
    return sse2_memmove(dst, src, n);
#else
    unsigned char *d = dst;
    const unsigned char *s = src;
    int sh1;
 
#ifdef __i386__
    if (sse2_supported)
        return sse2_memmove(dst, src, n);
#endif
 
    if (!n) return dst;
 
    if ((size_t)dst - (size_t)src >= n)
    {
        for (; (size_t)d % sizeof(size_t) && n; n--) *d++ = *s++;
 
        sh1 = 8 * ((size_t)s % sizeof(size_t));
        if (!sh1)
        {
            while (n >= sizeof(size_t))
            {
                *(size_t*)d = *(size_t*)s;
                s += sizeof(size_t);
                d += sizeof(size_t);
                n -= sizeof(size_t);
            }
        }
        else if (n >= 2 * sizeof(size_t))
        {
            int sh2 = 8 * sizeof(size_t) - sh1;
            size_t x, y;
 
            s -= sh1 / 8;
            x = *(size_t*)s;
            do
            {
                s += sizeof(size_t);
                y = *(size_t*)s;
                *(size_t*)d = MERGE(x, sh1, y, sh2);
                d += sizeof(size_t);
 
                s += sizeof(size_t);
                x = *(size_t*)s;
                *(size_t*)d = MERGE(y, sh1, x, sh2);
                d += sizeof(size_t);
 
                n -= 2 * sizeof(size_t);
            } while (n >= 2 * sizeof(size_t));
            s += sh1 / 8;
        }
        while (n--) *d++ = *s++;
        return dst;
    }
    else
    {
        d += n;
        s += n;
 
        for (; (size_t)d % sizeof(size_t) && n; n--) *--d = *--s;
 
        sh1 = 8 * ((size_t)s % sizeof(size_t));
        if (!sh1)
        {
            while (n >= sizeof(size_t))
            {
                s -= sizeof(size_t);
                d -= sizeof(size_t);
                *(size_t*)d = *(size_t*)s;
                n -= sizeof(size_t);
            }
        }
        else if (n >= 2 * sizeof(size_t))
        {
            int sh2 = 8 * sizeof(size_t) - sh1;
            size_t x, y;
 
            s -= sh1 / 8;
            x = *(size_t*)s;
            do
            {
                s -= sizeof(size_t);
                y = *(size_t*)s;
                d -= sizeof(size_t);
                *(size_t*)d = MERGE(y, sh1, x, sh2);
 
                s -= sizeof(size_t);
                x = *(size_t*)s;
                d -= sizeof(size_t);
                *(size_t*)d = MERGE(x, sh1, y, sh2);
 
                n -= 2 * sizeof(size_t);
            } while (n >= 2 * sizeof(size_t));
            s += sh1 / 8;
        }
        while (n--) *--d = *--s;
    }
    return dst;
#endif
}

memset()

void * memset	(	void *	dest,
		int	ch,
		uacpi_size	count
	)

Definition at line 3230 of file string.c.

{
    typedef uint64_t DECLSPEC_ALIGN(1) unaligned_ui64;
    typedef uint32_t DECLSPEC_ALIGN(1) unaligned_ui32;
    typedef uint16_t DECLSPEC_ALIGN(1) unaligned_ui16;
 
    uint64_t v = 0x101010101010101ull * (unsigned char)c;
    unsigned char *d = (unsigned char *)dst;
    size_t a = 0x20 - ((uintptr_t)d & 0x1f);
 
    if (n >= 16)
    {
        *(unaligned_ui64 *)(d + 0) = v;
        *(unaligned_ui64 *)(d + 8) = v;
        *(unaligned_ui64 *)(d + n - 16) = v;
        *(unaligned_ui64 *)(d + n - 8) = v;
        if (n <= 32) return dst;
        *(unaligned_ui64 *)(d + 16) = v;
        *(unaligned_ui64 *)(d + 24) = v;
        *(unaligned_ui64 *)(d + n - 32) = v;
        *(unaligned_ui64 *)(d + n - 24) = v;
        if (n <= 64) return dst;
 
        n = (n - a) & ~0x1f;
        memset_aligned_32(d + a, v, n);
        return dst;
    }
    if (n >= 8)
    {
        *(unaligned_ui64 *)d = v;
        *(unaligned_ui64 *)(d + n - 8) = v;
        return dst;
    }
    if (n >= 4)
    {
        *(unaligned_ui32 *)d = v;
        *(unaligned_ui32 *)(d + n - 4) = v;
        return dst;
    }
    if (n >= 2)
    {
        *(unaligned_ui16 *)d = v;
        *(unaligned_ui16 *)(d + n - 2) = v;
        return dst;
    }
    if (n >= 1)
    {
        *(uint8_t *)d = v;
        return dst;
    }
    return dst;
}

uacpi_bit_scan_backward()

uacpi_u8 uacpi_bit_scan_backward

(

uacpi_u64

value

)

Definition at line 154 of file stdlib.c.

{
#if defined(_MSC_VER) && !defined(__clang__)
    unsigned char ret;
    unsigned long index;
 
#ifdef _WIN64
    ret = _BitScanReverse64(&index, value);
    if (ret == 0)
        return 0;
 
    return (uacpi_u8)index + 1;
#else
    ret = _BitScanReverse(&index, value >> 32);
    if (ret == 0) {
        ret = _BitScanReverse(&index, value);
        if (ret == 0)
            return 0;
 
        return (uacpi_u8)index + 1;
    }
 
    return (uacpi_u8)index + 33;
#endif
 
#else
    if (value == 0)
        return 0;
 
    return 64 - __builtin_clzll(value);
#endif
}

Referenced by gas_get_access_bit_width(), and handle_unary_math().

uacpi_bit_scan_forward()

uacpi_u8 uacpi_bit_scan_forward

(

uacpi_u64

value

)

Definition at line 124 of file stdlib.c.

{
#if defined(_MSC_VER) && !defined(__clang__)
    unsigned char ret;
    unsigned long index;
 
#ifdef _WIN64
    ret = _BitScanForward64(&index, value);
    if (ret == 0)
        return 0;
 
    return (uacpi_u8)index + 1;
#else
    ret = _BitScanForward(&index, value);
    if (ret == 0) {
        ret = _BitScanForward(&index, value >> 32);
        if (ret == 0)
            return 0;
 
        return (uacpi_u8)index + 33;
    }
 
    return (uacpi_u8)index + 1;
#endif
 
#else
    return __builtin_ffsll(value);
#endif
}

Referenced by handle_unary_math().

uacpi_builtin_alloc_zeroed()

void * uacpi_builtin_alloc_zeroed

(

uacpi_size

size

)

Definition at line 188 of file stdlib.c.

{
    void *ptr;
 
    ptr = uacpi_kernel_alloc(size);
    if (uacpi_unlikely(ptr == UACPI_NULL))
        return ptr;
 
    uacpi_memzero(ptr, size);
    return ptr;
}

uacpi_memcpy_zerout()

void uacpi_memcpy_zerout	(	void *	dst,
		const void *	src,
		uacpi_size	dst_size,
		uacpi_size	src_size
	)

Definition at line 112 of file stdlib.c.

{
    uacpi_size bytes_to_copy = UACPI_MIN(src_size, dst_size);
 
    if (bytes_to_copy)
        uacpi_memcpy(dst, src, bytes_to_copy);
 
    if (dst_size > bytes_to_copy)
        uacpi_memzero((uacpi_u8 *)dst + bytes_to_copy, dst_size - bytes_to_copy);
}

Referenced by buffer_alloc_and_store(), build_table_id(), do_aml_resource_to_native(), do_native_resource_to_aml(), exec_op(), handle_buffer(), handle_ref_or_deref_of(), handle_special_field(), object_assign_with_implicit_cast(), object_to_integer(), uacpi_dispatch_opregion_io(), uacpi_read_field_unit(), uacpi_write_buffer_field(), and write_buffer_index().

uacpi_snprintf()

uacpi_i32 uacpi_snprintf	(	uacpi_char *	buffer,
		uacpi_size	capacity,
		const uacpi_char *	fmt,
			...
	)

Definition at line 661 of file stdlib.c.

{
    uacpi_va_list vlist;
    uacpi_i32 ret;
 
    uacpi_va_start(vlist, fmt);
    ret = uacpi_vsnprintf(buffer, capacity, fmt, vlist);
    uacpi_va_end(vlist);
 
    return ret;
}

Referenced by buffer_to_string(), handle_concatenate(), integer_to_string(), uacpi_eval_cls(), and uacpi_eval_uid().

uacpi_strcmp()

uacpi_i32 uacpi_strcmp	(	const uacpi_char *	lhs,
		const uacpi_char *	rhs
	)

Definition at line 96 of file stdlib.c.

{
    uacpi_size i = 0;
    typedef const uacpi_u8 *cucp;
 
    while (lhs[i] && rhs[i]) {
        if (lhs[i] != rhs[i])
            return *(cucp)&lhs[i] - *(cucp)&rhs[i];
 
        i++;
    }
 
    return *(cucp)&lhs[i] - *(cucp)&rhs[i];
}

Referenced by find_interface_unlocked(), matches_any(), and uacpi_uninstall_interface().

uacpi_strlen()

uacpi_size uacpi_strlen

(

const uacpi_char *

str

)

Definition at line 72 of file stdlib.c.

{
    const uacpi_char *str1;
 
    for (str1 = str; *str1; str1++);
 
    return str1 - str;
}

Referenced by consume(), uacpi_free_dynamic_string(), uacpi_install_interface(), uacpi_namespace_node_resolve(), and uacpi_object_create_cstring().

uacpi_strnlen()

uacpi_size uacpi_strnlen	(	const uacpi_char *	str,
		uacpi_size	max
	)

Definition at line 85 of file stdlib.c.

{
    const uacpi_char *str1;
 
    for (str1 = str; max-- && *str1; str1++);
 
    return str1 - str;
}

Referenced by handle_string(), and handle_to_string().

uacpi_vsnprintf()

uacpi_i32 uacpi_vsnprintf	(	uacpi_char *	buffer,
		uacpi_size	capacity,
		const uacpi_char *	fmt,
		uacpi_va_list	vlist
	)

Definition at line 475 of file stdlib.c.

{
    struct fmt_buf_state fb_state = {
        .buffer = buffer,
        .capacity = capacity,
        .bytes_written = 0
    };
 
    uacpi_u64 value;
    const uacpi_char *next_conversion;
    uacpi_size next_offset;
    uacpi_char flag;
 
    while (*fmt) {
        struct fmt_spec fm = {
            .pad_char = ' ',
            .base = 10,
        };
        next_conversion = find_next_conversion(fmt, &next_offset);
 
        if (next_offset)
            write_many(&fb_state, fmt, next_offset);
 
        if (!next_conversion)
            break;
 
        fmt = next_conversion;
        if (consume(&fmt, "%%")) {
            write_one(&fb_state, '%');
            continue;
        }
 
        // consume %
        fmt++;
 
        while (consume_one_of(&fmt, "+- 0#", &flag)) {
            switch (flag) {
            case '+':
            case ' ':
                fm.prepend = UACPI_TRUE;
                fm.prepend_char = flag;
                continue;
            case '-':
                fm.left_justify = UACPI_TRUE;
                continue;
            case '0':
                fm.pad_char = '0';
                continue;
            case '#':
                fm.alternate_form = UACPI_TRUE;
                continue;
            default:
                return -1;
            }
        }
 
        if (consume(&fmt, "*")) {
            fm.min_width = uacpi_va_arg(vlist, int);
        } else if (!parse_number(&fmt, PARSE_NUMBER_MODE_MAYBE, &fm.min_width)) {
            return -1;
        }
 
        if (consume(&fmt, ".")) {
            fm.has_precision = UACPI_TRUE;
 
            if (consume(&fmt, "*")) {
                fm.precision = uacpi_va_arg(vlist, int);
            } else {
                if (!parse_number(&fmt, PARSE_NUMBER_MODE_MUST, &fm.precision))
                    return -1;
            }
        }
 
        flag = 0;
 
        if (consume(&fmt, "c")) {
            uacpi_char c = uacpi_va_arg(vlist, int);
            write_one(&fb_state, c);
            continue;
        }
 
        if (consume(&fmt, "s")) {
            const uacpi_char *string = uacpi_va_arg(vlist, uacpi_char*);
            uacpi_size i;
 
            if (uacpi_unlikely(string == UACPI_NULL))
                string = "<null>";
 
            for (i = 0; (!fm.has_precision || i < fm.precision) && string[i]; ++i)
                write_one(&fb_state, string[i]);
            while (i++ < fm.min_width)
                write_one(&fb_state, ' ');
            continue;
        }
 
        if (consume(&fmt, "p")) {
            value = (uacpi_uintptr)uacpi_va_arg(vlist, void*);
            fm.base = 16;
            fm.min_width = UACPI_POINTER_SIZE * 2;
            fm.pad_char = '0';
            goto write_int;
        }
 
        if (consume(&fmt, "hh")) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = (signed char)uacpi_va_arg(vlist, int);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = (unsigned char)uacpi_va_arg(vlist, int);
            } else {
                return -1;
            }
            goto write_int;
        }
 
        if (consume(&fmt, "h")) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = (signed short)uacpi_va_arg(vlist, int);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = (unsigned short)uacpi_va_arg(vlist, int);
            } else {
                return -1;
            }
            goto write_int;
        }
 
        if (consume(&fmt, "ll") ||
            (sizeof(uacpi_size) == sizeof(long long) && consume(&fmt, "z"))) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = uacpi_va_arg(vlist, long long);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = uacpi_va_arg(vlist, unsigned long long);
            } else {
                return -1;
            }
            goto write_int;
        }
 
        if (consume(&fmt, "l") ||
            (sizeof(uacpi_size) == sizeof(long) && consume(&fmt, "z"))) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = uacpi_va_arg(vlist, long);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = uacpi_va_arg(vlist, unsigned long);
            } else {
                return -1;
            }
            goto write_int;
        }
 
        if (consume(&fmt, "d") || consume(&fmt, "i")) {
            value = uacpi_va_arg(vlist, uacpi_i32);
            fm.is_signed = UACPI_TRUE;
        } else if (consume_one_of(&fmt, "oxXu", &flag)) {
            value = uacpi_va_arg(vlist, uacpi_u32);
        } else {
            return -1;
        }
 
    write_int:
        if (flag != 0) {
            fm.base = base_from_specifier(flag);
            fm.uppercase = is_uppercase_specifier(flag);
        }
 
        write_integer(&fb_state, &fm, value);
    }
 
    if (fb_state.capacity) {
        uacpi_size last_char;
 
        last_char = UACPI_MIN(fb_state.bytes_written, fb_state.capacity - 1);
        fb_state.buffer[last_char] = '\0';
    }
 
    return fb_state.bytes_written;
}

Referenced by uacpi_log(), and uacpi_snprintf().