Hi, > I've some problems to reproduce this. I understand; reproduction is easy but only if you've setup the entire Zephyr environment. It's not complicated but it does take some time. > Would it be possible to get the result of the preprocessing of the > file tls.c ? Funny enough, when using sparse the Zephyr build system prints the command only AFTER sparse has run :-( Fortunately, copying the command from `ps` worked! No evil environment variable required. More good news: running `sparse tls.i` on this pre-processed file reproduces instantly for me. So see tls.i file below. In case my mailer mangled the file (I gave up on plain text email a long time ago, sorry about that) I also attached it to the issue: https://github.com/zephyrproject-rtos/zephyr/issues/63417 I doubt this list accepts attachments... I can also create a bug at bugzilla.kernel.org if you prefer. Marc typedef long ptrdiff_t; typedef unsigned long size_t; typedef int wchar_t; typedef unsigned char __u_char; typedef unsigned short int __u_short; typedef unsigned int __u_int; typedef unsigned long int __u_long; typedef signed char __int8_t; typedef unsigned char __uint8_t; typedef signed short int __int16_t; typedef unsigned short int __uint16_t; typedef signed int __int32_t; typedef unsigned int __uint32_t; typedef signed long int __int64_t; typedef unsigned long int __uint64_t; typedef __int8_t __int_least8_t; typedef __uint8_t __uint_least8_t; typedef __int16_t __int_least16_t; typedef __uint16_t __uint_least16_t; typedef __int32_t __int_least32_t; typedef __uint32_t __uint_least32_t; typedef __int64_t __int_least64_t; typedef __uint64_t __uint_least64_t; typedef long int __quad_t; typedef unsigned long int __u_quad_t; typedef long int __intmax_t; typedef unsigned long int __uintmax_t; typedef unsigned long int __dev_t; typedef unsigned int __uid_t; typedef unsigned int __gid_t; typedef unsigned long int __ino_t; typedef unsigned long int __ino64_t; typedef unsigned int __mode_t; typedef unsigned long int __nlink_t; typedef long int __off_t; typedef long int __off64_t; typedef int __pid_t; typedef struct { int __val[2]; } __fsid_t; typedef long int __clock_t; typedef unsigned long int __rlim_t; typedef unsigned long int __rlim64_t; typedef unsigned int __id_t; typedef long int __time_t; typedef unsigned int __useconds_t; typedef long int __suseconds_t; typedef long int __suseconds64_t; typedef int __daddr_t; typedef int __key_t; typedef int __clockid_t; typedef void * __timer_t; typedef long int __blksize_t; typedef long int __blkcnt_t; typedef long int __blkcnt64_t; typedef unsigned long int __fsblkcnt_t; typedef unsigned long int __fsblkcnt64_t; typedef unsigned long int __fsfilcnt_t; typedef unsigned long int __fsfilcnt64_t; typedef long int __fsword_t; typedef long int __ssize_t; typedef long int __syscall_slong_t; typedef unsigned long int __syscall_ulong_t; typedef __off64_t __loff_t; typedef char *__caddr_t; typedef long int __intptr_t; typedef unsigned int __socklen_t; typedef int __sig_atomic_t; typedef __int8_t int8_t; typedef __int16_t int16_t; typedef __int32_t int32_t; typedef __int64_t int64_t; typedef __uint8_t uint8_t; typedef __uint16_t uint16_t; typedef __uint32_t uint32_t; typedef __uint64_t uint64_t; typedef __int_least8_t int_least8_t; typedef __int_least16_t int_least16_t; typedef __int_least32_t int_least32_t; typedef __int_least64_t int_least64_t; typedef __uint_least8_t uint_least8_t; typedef __uint_least16_t uint_least16_t; typedef __uint_least32_t uint_least32_t; typedef __uint_least64_t uint_least64_t; typedef signed char int_fast8_t; typedef long int int_fast16_t; typedef long int int_fast32_t; typedef long int int_fast64_t; typedef unsigned char uint_fast8_t; typedef unsigned long int uint_fast16_t; typedef unsigned long int uint_fast32_t; typedef unsigned long int uint_fast64_t; typedef long int intptr_t; typedef unsigned long int uintptr_t; typedef __intmax_t intmax_t; typedef __uintmax_t uintmax_t; typedef union { long long thelonglong; long double thelongdouble; uintmax_t theuintmax_t; size_t thesize_t; uintptr_t theuintptr_t; void *thepvoid; void (*thepfunc)(void); } z_max_align_t; typedef long atomic_t; typedef atomic_t atomic_val_t; typedef void *atomic_ptr_t; typedef atomic_ptr_t atomic_ptr_val_t; static inline _Bool atomic_cas(atomic_t *target, atomic_val_t old_value, atomic_val_t new_value) { return __atomic_compare_exchange_n(target, &old_value, new_value, 0, 8, 8); } static inline _Bool atomic_ptr_cas(atomic_ptr_t *target, atomic_ptr_val_t old_value, atomic_ptr_val_t new_value) { return __atomic_compare_exchange_n(target, &old_value, new_value, 0, 8, 8); } static inline atomic_val_t atomic_add(atomic_t *target, atomic_val_t value) { return __atomic_fetch_add(target, value, 8); } static inline atomic_val_t atomic_sub(atomic_t *target, atomic_val_t value) { return __atomic_fetch_sub(target, value, 8); } static inline atomic_val_t atomic_inc(atomic_t *target) { return atomic_add(target, 1); } static inline atomic_val_t atomic_dec(atomic_t *target) { return atomic_sub(target, 1); } static inline atomic_val_t atomic_get(const atomic_t *target) { return __atomic_load_n(target, 8); } static inline atomic_ptr_val_t atomic_ptr_get(const atomic_ptr_t *target) { return __atomic_load_n(target, 8); } static inline atomic_val_t atomic_set(atomic_t *target, atomic_val_t value) { return __atomic_exchange_n(target, value, 8); } static inline atomic_ptr_val_t atomic_ptr_set(atomic_ptr_t *target, atomic_ptr_val_t value) { return __atomic_exchange_n(target, value, 8); } static inline atomic_val_t atomic_clear(atomic_t *target) { return atomic_set(target, 0); } static inline atomic_ptr_val_t atomic_ptr_clear(atomic_ptr_t *target) { return atomic_ptr_set(target, ((void *)0)); } static inline atomic_val_t atomic_or(atomic_t *target, atomic_val_t value) { return __atomic_fetch_or(target, value, 8); } static inline atomic_val_t atomic_xor(atomic_t *target, atomic_val_t value) { return __atomic_fetch_xor(target, value, 8); } static inline atomic_val_t atomic_and(atomic_t *target, atomic_val_t value) { return __atomic_fetch_and(target, value, 8); } static inline atomic_val_t atomic_nand(atomic_t *target, atomic_val_t value) { return __atomic_fetch_nand(target, value, 8); } static inline _Bool atomic_test_bit(const atomic_t *target, int bit) { atomic_val_t val = atomic_get(((target) + ((bit) / (sizeof(atomic_val_t) * 8)))); return (1 & (val >> (bit & ((sizeof(atomic_val_t) * 8) - 1)))) != 0; } static inline _Bool atomic_test_and_clear_bit(atomic_t *target, int bit) { atomic_val_t mask = (1UL << ((unsigned long)(bit) & ((sizeof(atomic_val_t) * 8) - 1U))); atomic_val_t old; old = atomic_and(((target) + ((bit) / (sizeof(atomic_val_t) * 8))), ~mask); return (old & mask) != 0; } static inline _Bool atomic_test_and_set_bit(atomic_t *target, int bit) { atomic_val_t mask = (1UL << ((unsigned long)(bit) & ((sizeof(atomic_val_t) * 8) - 1U))); atomic_val_t old; old = atomic_or(((target) + ((bit) / (sizeof(atomic_val_t) * 8))), mask); return (old & mask) != 0; } static inline void atomic_clear_bit(atomic_t *target, int bit) { atomic_val_t mask = (1UL << ((unsigned long)(bit) & ((sizeof(atomic_val_t) * 8) - 1U))); (void)atomic_and(((target) + ((bit) / (sizeof(atomic_val_t) * 8))), ~mask); } static inline void atomic_set_bit(atomic_t *target, int bit) { atomic_val_t mask = (1UL << ((unsigned long)(bit) & ((sizeof(atomic_val_t) * 8) - 1U))); (void)atomic_or(((target) + ((bit) / (sizeof(atomic_val_t) * 8))), mask); } static inline void atomic_set_bit_to(atomic_t *target, int bit, _Bool val) { atomic_val_t mask = (1UL << ((unsigned long)(bit) & ((sizeof(atomic_val_t) * 8) - 1U))); if (val) { (void)atomic_or(((target) + ((bit) / (sizeof(atomic_val_t) * 8))), mask); } else { (void)atomic_and(((target) + ((bit) / (sizeof(atomic_val_t) * 8))), ~mask); } } void __attribute__((format (printf, 1, 2))) assert_print(const char *fmt, ...); static inline _Bool is_power_of_two(unsigned int x) { return (((x) != 0U) && (((x) & ((x) - 1U)) == 0U)); } static inline int64_t arithmetic_shift_right(int64_t value, uint8_t shift) { int64_t sign_ext; if (shift == 0U) { return value; } sign_ext = (value >> 63) & 1; sign_ext = -sign_ext; return (value >> shift) | (sign_ext << (64 - shift)); } static inline void bytecpy(void *dst, const void *src, size_t size) { size_t i; for (i = 0; i < size; ++i) { ((volatile uint8_t *)dst)[i] = ((volatile const uint8_t *)src)[i]; } } static inline void byteswp(void *a, void *b, size_t size) { uint8_t t; uint8_t *aa = (uint8_t *)a; uint8_t *bb = (uint8_t *)b; for (; size > 0; --size) { t = *aa; *aa++ = *bb; *bb++ = t; } } int char2hex(char c, uint8_t *x); int hex2char(uint8_t x, char *c); size_t bin2hex(const uint8_t *buf, size_t buflen, char *hex, size_t hexlen); size_t hex2bin(const char *hex, size_t hexlen, uint8_t *buf, size_t buflen); static inline uint8_t bcd2bin(uint8_t bcd) { return ((10 * (bcd >> 4)) + (bcd & 0x0F)); } static inline uint8_t bin2bcd(uint8_t bin) { return (((bin / 10) << 4) | (bin % 10)); } uint8_t u8_to_dec(char *buf, uint8_t buflen, uint8_t value); char *utf8_trunc(char *utf8_str); char *utf8_lcpy(char *dst, const char *src, size_t n); static inline int sys_clock_hw_cycles_per_sec_runtime_get(void); static inline int z_impl_sys_clock_hw_cycles_per_sec_runtime_get(void) { extern int z_clock_hw_cycles_per_sec; return z_clock_hw_cycles_per_sec; } typedef __builtin_va_list __gnuc_va_list; typedef __gnuc_va_list va_list; typedef uintptr_t (*_k_syscall_handler_t)(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, void *ssf); static inline __attribute__((always_inline)) _Bool z_syscall_trap(void) { _Bool ret = 0; return ret; } static inline _Bool k_is_user_context(void) { return 0; } extern int z_impl_sys_clock_hw_cycles_per_sec_runtime_get(void); static inline int sys_clock_hw_cycles_per_sec_runtime_get(void) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_sys_clock_hw_cycles_per_sec_runtime_get(); } struct _dnode { union { struct _dnode *head; struct _dnode *next; }; union { struct _dnode *tail; struct _dnode *prev; }; }; typedef struct _dnode sys_dlist_t; typedef struct _dnode sys_dnode_t; static inline void sys_dlist_init(sys_dlist_t *list) { list->head = (sys_dnode_t *)list; list->tail = (sys_dnode_t *)list; } static inline void sys_dnode_init(sys_dnode_t *node) { node->next = ((void *)0); node->prev = ((void *)0); } static inline _Bool sys_dnode_is_linked(const sys_dnode_t *node) { return node->next != ((void *)0); } static inline _Bool sys_dlist_is_head(sys_dlist_t *list, sys_dnode_t *node) { return list->head == node; } static inline _Bool sys_dlist_is_tail(sys_dlist_t *list, sys_dnode_t *node) { return list->tail == node; } static inline _Bool sys_dlist_is_empty(sys_dlist_t *list) { return list->head == list; } static inline _Bool sys_dlist_has_multiple_nodes(sys_dlist_t *list) { return list->head != list->tail; } static inline sys_dnode_t *sys_dlist_peek_head(sys_dlist_t *list) { return sys_dlist_is_empty(list) ? ((void *)0) : list->head; } static inline sys_dnode_t *sys_dlist_peek_head_not_empty(sys_dlist_t *list) { return list->head; } static inline sys_dnode_t *sys_dlist_peek_next_no_check(sys_dlist_t *list, sys_dnode_t *node) { return (node == list->tail) ? ((void *)0) : node->next; } static inline sys_dnode_t *sys_dlist_peek_next(sys_dlist_t *list, sys_dnode_t *node) { return (node != ((void *)0)) ? sys_dlist_peek_next_no_check(list, node) : ((void *)0); } static inline sys_dnode_t *sys_dlist_peek_prev_no_check(sys_dlist_t *list, sys_dnode_t *node) { return (node == list->head) ? ((void *)0) : node->prev; } static inline sys_dnode_t *sys_dlist_peek_prev(sys_dlist_t *list, sys_dnode_t *node) { return (node != ((void *)0)) ? sys_dlist_peek_prev_no_check(list, node) : ((void *)0); } static inline sys_dnode_t *sys_dlist_peek_tail(sys_dlist_t *list) { return sys_dlist_is_empty(list) ? ((void *)0) : list->tail; } static inline void sys_dlist_append(sys_dlist_t *list, sys_dnode_t *node) { sys_dnode_t *const tail = list->tail; node->next = list; node->prev = tail; tail->next = node; list->tail = node; } static inline void sys_dlist_prepend(sys_dlist_t *list, sys_dnode_t *node) { sys_dnode_t *const head = list->head; node->next = head; node->prev = list; head->prev = node; list->head = node; } static inline void sys_dlist_insert(sys_dnode_t *successor, sys_dnode_t *node) { sys_dnode_t *const prev = successor->prev; node->prev = prev; node->next = successor; prev->next = node; successor->prev = node; } static inline void sys_dlist_insert_at(sys_dlist_t *list, sys_dnode_t *node, int (*cond)(sys_dnode_t *node, void *data), void *data) { if (sys_dlist_is_empty(list)) { sys_dlist_append(list, node); } else { sys_dnode_t *pos = sys_dlist_peek_head(list); while ((pos != ((void *)0)) && (cond(pos, data) == 0)) { pos = sys_dlist_peek_next(list, pos); } if (pos != ((void *)0)) { sys_dlist_insert(pos, node); } else { sys_dlist_append(list, node); } } } static inline void sys_dlist_remove(sys_dnode_t *node) { sys_dnode_t *const prev = node->prev; sys_dnode_t *const next = node->next; prev->next = next; next->prev = prev; sys_dnode_init(node); } static inline sys_dnode_t *sys_dlist_get(sys_dlist_t *list) { sys_dnode_t *node = ((void *)0); if (!sys_dlist_is_empty(list)) { node = list->head; sys_dlist_remove(node); } return node; } static inline size_t sys_dlist_len(sys_dlist_t *list) { size_t len = 0; sys_dnode_t *node = ((void *)0); for (node = sys_dlist_peek_head(list); node != ((void *)0); node = sys_dlist_peek_next(list, node)) { len++; } return len; } struct rbnode { struct rbnode *children[2]; }; typedef _Bool (*rb_lessthan_t)(struct rbnode *a, struct rbnode *b); struct rbtree { struct rbnode *root; rb_lessthan_t lessthan_fn; int max_depth; }; typedef void (*rb_visit_t)(struct rbnode *node, void *cookie); struct rbnode *z_rb_child(struct rbnode *node, uint8_t side); int z_rb_is_black(struct rbnode *node); void z_rb_walk(struct rbnode *node, rb_visit_t visit_fn, void *cookie); struct rbnode *z_rb_get_minmax(struct rbtree *tree, uint8_t side); void rb_insert(struct rbtree *tree, struct rbnode *node); void rb_remove(struct rbtree *tree, struct rbnode *node); static inline struct rbnode *rb_get_min(struct rbtree *tree) { return z_rb_get_minmax(tree, 0U); } static inline struct rbnode *rb_get_max(struct rbtree *tree) { return z_rb_get_minmax(tree, 1U); } _Bool rb_contains(struct rbtree *tree, struct rbnode *node); static inline void rb_walk(struct rbtree *tree, rb_visit_t visit_fn, void *cookie) { z_rb_walk(tree->root, visit_fn, cookie); } struct _rb_foreach { struct rbnode **stack; uint8_t *is_left; int32_t top; }; struct rbnode *z_rb_foreach_next(struct rbtree *tree, struct _rb_foreach *f); struct k_thread; struct k_thread *z_priq_dumb_best(sys_dlist_t *pq); void z_priq_dumb_remove(sys_dlist_t *pq, struct k_thread *thread); struct _priq_rb { struct rbtree tree; int next_order_key; }; void z_priq_rb_add(struct _priq_rb *pq, struct k_thread *thread); void z_priq_rb_remove(struct _priq_rb *pq, struct k_thread *thread); struct k_thread *z_priq_rb_best(struct _priq_rb *pq); struct _priq_mq { sys_dlist_t queues[32]; unsigned int bitmask; }; struct k_thread *z_priq_mq_best(struct _priq_mq *pq); struct _snode { struct _snode *next; }; typedef struct _snode sys_snode_t; struct _slist { sys_snode_t *head; sys_snode_t *tail; }; typedef struct _slist sys_slist_t; static inline void sys_slist_init(sys_slist_t *list) { list->head = ((void *)0); list->tail = ((void *)0); } static inline sys_snode_t *z_snode_next_peek(sys_snode_t *node) { return node->next; } static inline void z_snode_next_set(sys_snode_t *parent, sys_snode_t *child) { parent->next = child; } static inline void z_slist_head_set(sys_slist_t *list, sys_snode_t *node) { list->head = node; } static inline void z_slist_tail_set(sys_slist_t *list, sys_snode_t *node) { list->tail = node; } static inline sys_snode_t *sys_slist_peek_head(sys_slist_t *list) { return list->head; } static inline sys_snode_t *sys_slist_peek_tail(sys_slist_t *list) { return list->tail; } static inline _Bool sys_slist_is_empty(sys_slist_t *list); static inline _Bool sys_slist_is_empty(sys_slist_t *list) { return (sys_slist_peek_head(list) == ((void *)0)); } static inline sys_snode_t *sys_slist_peek_next_no_check(sys_snode_t *node); static inline sys_snode_t * sys_slist_peek_next_no_check(sys_snode_t *node) { return z_snode_next_peek(node); } static inline sys_snode_t *sys_slist_peek_next(sys_snode_t *node); static inline sys_snode_t * sys_slist_peek_next(sys_snode_t *node) { return node != ((void *)0) ? sys_slist_peek_next_no_check(node) : ((void *)0); } static inline void sys_slist_prepend(sys_slist_t *list, sys_snode_t *node); static inline void sys_slist_prepend(sys_slist_t *list, sys_snode_t *node) { z_snode_next_set(node, sys_slist_peek_head(list)); z_slist_head_set(list, node); if (sys_slist_peek_tail(list) == ((void *)0)) { z_slist_tail_set(list, sys_slist_peek_head(list)); } } static inline void sys_slist_append(sys_slist_t *list, sys_snode_t *node); static inline void sys_slist_append(sys_slist_t *list, sys_snode_t *node) { z_snode_next_set(node, ((void *)0)); if (sys_slist_peek_tail(list) == ((void *)0)) { z_slist_tail_set(list, node); z_slist_head_set(list, node); } else { z_snode_next_set( sys_slist_peek_tail(list), node); z_slist_tail_set(list, node); } } static inline void sys_slist_append_list(sys_slist_t *list, void *head, void *tail); static inline void sys_slist_append_list(sys_slist_t *list, void *head, void *tail) { if (head != ((void *)0) && tail != ((void *)0)) { if (sys_slist_peek_tail(list) == ((void *)0)) { z_slist_head_set(list, (sys_snode_t *)head); } else { z_snode_next_set( sys_slist_peek_tail(list), (sys_snode_t *)head); } z_slist_tail_set(list, (sys_snode_t *)tail); } } static inline void sys_slist_merge_slist(sys_slist_t *list, sys_slist_t *list_to_append); static inline void sys_slist_merge_slist ( sys_slist_t *list, sys_slist_t *list_to_append) { sys_snode_t *head, *tail; head = sys_slist_peek_head(list_to_append); tail = sys_slist_peek_tail(list_to_append); sys_slist_append_list(list, head, tail); sys_slist_init(list_to_append); } static inline void sys_slist_insert(sys_slist_t *list, sys_snode_t *prev, sys_snode_t *node); static inline void sys_slist_insert(sys_slist_t *list, sys_snode_t *prev, sys_snode_t *node) { if (prev == ((void *)0)) { sys_slist_prepend(list, node); } else if (z_snode_next_peek(prev) == ((void *)0)) { sys_slist_append(list, node); } else { z_snode_next_set(node, z_snode_next_peek(prev)); z_snode_next_set(prev, node); } } static inline sys_snode_t *sys_slist_get_not_empty(sys_slist_t *list); static inline sys_snode_t * sys_slist_get_not_empty(sys_slist_t *list) { sys_snode_t *node = sys_slist_peek_head(list); z_slist_head_set(list, z_snode_next_peek(node)); if (sys_slist_peek_tail(list) == node) { z_slist_tail_set(list, sys_slist_peek_head(list)); } return node; } static inline sys_snode_t *sys_slist_get(sys_slist_t *list); static inline sys_snode_t * sys_slist_get(sys_slist_t *list) { return sys_slist_is_empty(list) ? ((void *)0) : sys_slist_get_not_empty(list); } static inline void sys_slist_remove(sys_slist_t *list, sys_snode_t *prev_node, sys_snode_t *node); static inline void sys_slist_remove(sys_slist_t *list, sys_snode_t *prev_node, sys_snode_t *node) { if (prev_node == ((void *)0)) { z_slist_head_set(list, z_snode_next_peek(node)); if (sys_slist_peek_tail(list) == node) { z_slist_tail_set(list, sys_slist_peek_head(list)); } } else { z_snode_next_set(prev_node, z_snode_next_peek(node)); if (sys_slist_peek_tail(list) == node) { z_slist_tail_set(list, prev_node); } } z_snode_next_set(node, ((void *)0)); } static inline _Bool sys_slist_find_and_remove(sys_slist_t *list, sys_snode_t *node); static inline size_t sys_slist_len(sys_slist_t *list); static inline size_t sys_slist_len(sys_slist_t * list) { size_t len = 0; static sys_snode_t * node; for (node = sys_slist_peek_head(list); node != ((void *)0); node = sys_slist_peek_next(node)) { len++; } return len; } static inline _Bool sys_slist_find_and_remove(sys_slist_t *list, sys_snode_t *node) { sys_snode_t *prev = ((void *)0); sys_snode_t *test; for (test = sys_slist_peek_head(list); test != ((void *)0); test = sys_slist_peek_next(test)) { if (test == node) { sys_slist_remove(list, prev, node); return 1; } prev = test; } return 0; } typedef uint64_t unative_t; struct _sfnode { unative_t next_and_flags; }; typedef struct _sfnode sys_sfnode_t; struct _sflist { sys_sfnode_t *head; sys_sfnode_t *tail; }; typedef struct _sflist sys_sflist_t; static inline void sys_sflist_init(sys_sflist_t *list) { list->head = ((void *)0); list->tail = ((void *)0); } static inline sys_sfnode_t *z_sfnode_next_peek(sys_sfnode_t *node) { return (sys_sfnode_t *)(node->next_and_flags & ~0x3UL); } static inline uint8_t sys_sfnode_flags_get(sys_sfnode_t *node); static inline void z_sfnode_next_set(sys_sfnode_t *parent, sys_sfnode_t *child) { uint8_t cur_flags = sys_sfnode_flags_get(parent); parent->next_and_flags = cur_flags | (unative_t)child; } static inline void z_sflist_head_set(sys_sflist_t *list, sys_sfnode_t *node) { list->head = node; } static inline void z_sflist_tail_set(sys_sflist_t *list, sys_sfnode_t *node) { list->tail = node; } static inline sys_sfnode_t *sys_sflist_peek_head(sys_sflist_t *list) { return list->head; } static inline sys_sfnode_t *sys_sflist_peek_tail(sys_sflist_t *list) { return list->tail; } static inline uint8_t sys_sfnode_flags_get(sys_sfnode_t *node) { return node->next_and_flags & 0x3UL; } static inline void sys_sfnode_init(sys_sfnode_t *node, uint8_t flags) { { }; node->next_and_flags = flags; } static inline void sys_sfnode_flags_set(sys_sfnode_t *node, uint8_t flags) { { }; node->next_and_flags = (unative_t)(z_sfnode_next_peek(node)) | flags; } static inline _Bool sys_sflist_is_empty(sys_sflist_t *list); static inline _Bool sys_sflist_is_empty(sys_sflist_t *list) { return (sys_sflist_peek_head(list) == ((void *)0)); } static inline sys_sfnode_t *sys_sflist_peek_next_no_check(sys_sfnode_t *node); static inline sys_sfnode_t * sys_sflist_peek_next_no_check(sys_sfnode_t *node) { return z_sfnode_next_peek(node); } static inline sys_sfnode_t *sys_sflist_peek_next(sys_sfnode_t *node); static inline sys_sfnode_t * sys_sflist_peek_next(sys_sfnode_t *node) { return node != ((void *)0) ? sys_sflist_peek_next_no_check(node) : ((void *)0); } static inline void sys_sflist_prepend(sys_sflist_t *list, sys_sfnode_t *node); static inline void sys_sflist_prepend(sys_sflist_t *list, sys_sfnode_t *node) { z_sfnode_next_set(node, sys_sflist_peek_head(list)); z_sflist_head_set(list, node); if (sys_sflist_peek_tail(list) == ((void *)0)) { z_sflist_tail_set(list, sys_sflist_peek_head(list)); } } static inline void sys_sflist_append(sys_sflist_t *list, sys_sfnode_t *node); static inline void sys_sflist_append(sys_sflist_t *list, sys_sfnode_t *node) { z_sfnode_next_set(node, ((void *)0)); if (sys_sflist_peek_tail(list) == ((void *)0)) { z_sflist_tail_set(list, node); z_sflist_head_set(list, node); } else { z_sfnode_next_set( sys_sflist_peek_tail(list), node); z_sflist_tail_set(list, node); } } static inline void sys_sflist_append_list(sys_sflist_t *list, void *head, void *tail); static inline void sys_sflist_append_list(sys_sflist_t *list, void *head, void *tail) { if (head != ((void *)0) && tail != ((void *)0)) { if (sys_sflist_peek_tail(list) == ((void *)0)) { z_sflist_head_set(list, (sys_sfnode_t *)head); } else { z_sfnode_next_set( sys_sflist_peek_tail(list), (sys_sfnode_t *)head); } z_sflist_tail_set(list, (sys_sfnode_t *)tail); } } static inline void sys_sflist_merge_sflist(sys_sflist_t *list, sys_sflist_t *list_to_append); static inline void sys_sflist_merge_sflist ( sys_sflist_t *list, sys_sflist_t *list_to_append) { sys_sfnode_t *head, *tail; head = sys_sflist_peek_head(list_to_append); tail = sys_sflist_peek_tail(list_to_append); sys_sflist_append_list(list, head, tail); sys_sflist_init(list_to_append); } static inline void sys_sflist_insert(sys_sflist_t *list, sys_sfnode_t *prev, sys_sfnode_t *node); static inline void sys_sflist_insert(sys_sflist_t *list, sys_sfnode_t *prev, sys_sfnode_t *node) { if (prev == ((void *)0)) { sys_sflist_prepend(list, node); } else if (z_sfnode_next_peek(prev) == ((void *)0)) { sys_sflist_append(list, node); } else { z_sfnode_next_set(node, z_sfnode_next_peek(prev)); z_sfnode_next_set(prev, node); } } static inline sys_sfnode_t *sys_sflist_get_not_empty(sys_sflist_t *list); static inline sys_sfnode_t * sys_sflist_get_not_empty(sys_sflist_t *list) { sys_sfnode_t *node = sys_sflist_peek_head(list); z_sflist_head_set(list, z_sfnode_next_peek(node)); if (sys_sflist_peek_tail(list) == node) { z_sflist_tail_set(list, sys_sflist_peek_head(list)); } return node; } static inline sys_sfnode_t *sys_sflist_get(sys_sflist_t *list); static inline sys_sfnode_t * sys_sflist_get(sys_sflist_t *list) { return sys_sflist_is_empty(list) ? ((void *)0) : sys_sflist_get_not_empty(list); } static inline void sys_sflist_remove(sys_sflist_t *list, sys_sfnode_t *prev_node, sys_sfnode_t *node); static inline void sys_sflist_remove(sys_sflist_t *list, sys_sfnode_t *prev_node, sys_sfnode_t *node) { if (prev_node == ((void *)0)) { z_sflist_head_set(list, z_sfnode_next_peek(node)); if (sys_sflist_peek_tail(list) == node) { z_sflist_tail_set(list, sys_sflist_peek_head(list)); } } else { z_sfnode_next_set(prev_node, z_sfnode_next_peek(node)); if (sys_sflist_peek_tail(list) == node) { z_sflist_tail_set(list, prev_node); } } z_sfnode_next_set(node, ((void *)0)); } static inline _Bool sys_sflist_find_and_remove(sys_sflist_t *list, sys_sfnode_t *node); static inline _Bool sys_sflist_find_and_remove(sys_sflist_t *list, sys_sfnode_t *node) { sys_sfnode_t *prev = ((void *)0); sys_sfnode_t *test; for (test = sys_sflist_peek_head(list); test != ((void *)0); test = sys_sflist_peek_next(test)) { if (test == node) { sys_sflist_remove(list, prev, node); return 1; } prev = test; } return 0; } static inline size_t sys_sflist_len(sys_sflist_t *list); static inline size_t sys_sflist_len(sys_sflist_t * list) { size_t len = 0; static sys_sfnode_t * node; for (node = sys_sflist_peek_head(list); node != ((void *)0); node = sys_sflist_peek_next(node)) { len++; } return len; } struct k_obj_type; struct k_obj_core; extern sys_slist_t z_obj_type_list; struct k_obj_core_stats_desc { size_t raw_size; size_t query_size; int (*raw)(struct k_obj_core *obj_core, void *stats); int (*query)(struct k_obj_core *obj_core, void *stats); int (*reset)(struct k_obj_core *obj_core); int (*disable)(struct k_obj_core *obj_core); int (*enable)(struct k_obj_core *obj_core); }; struct k_obj_type { sys_snode_t node; sys_slist_t list; uint32_t id; size_t obj_core_offset; }; struct k_obj_core { sys_snode_t node; struct k_obj_type *type; }; struct k_obj_type *z_obj_type_init(struct k_obj_type *type, uint32_t id, size_t off); struct k_obj_type *k_obj_type_find(uint32_t type_id); int k_obj_type_walk_locked(struct k_obj_type *type, int (*func)(struct k_obj_core *, void *), void *data); int k_obj_type_walk_unlocked(struct k_obj_type *type, int (*func)(struct k_obj_core *, void *), void *data); void k_obj_core_init(struct k_obj_core *obj_core, struct k_obj_type *type); void k_obj_core_link(struct k_obj_core *obj_core); void k_obj_core_init_and_link(struct k_obj_core *obj_core, struct k_obj_type *type); void k_obj_core_unlink(struct k_obj_core *obj_core); int k_obj_core_stats_register(struct k_obj_core *obj_core, void *stats, size_t stats_len); int k_obj_core_stats_deregister(struct k_obj_core *obj_core); int k_obj_core_stats_raw(struct k_obj_core *obj_core, void *stats, size_t stats_len); int k_obj_core_stats_query(struct k_obj_core *obj_core, void *stats, size_t stats_len); int k_obj_core_stats_reset(struct k_obj_core *obj_core); int k_obj_core_stats_disable(struct k_obj_core *obj_core); int k_obj_core_stats_enable(struct k_obj_core *obj_core); struct sys_memory_stats { size_t free_bytes; size_t allocated_bytes; size_t max_allocated_bytes; }; struct sys_heap { struct z_heap *heap; void *init_mem; size_t init_bytes; }; struct z_heap_stress_result { uint32_t total_allocs; uint32_t successful_allocs; uint32_t total_frees; uint64_t accumulated_in_use_bytes; }; void sys_heap_init(struct sys_heap *heap, void *mem, size_t bytes); void *sys_heap_alloc(struct sys_heap *heap, size_t bytes); void *sys_heap_aligned_alloc(struct sys_heap *heap, size_t align, size_t bytes); void sys_heap_free(struct sys_heap *heap, void *mem); void *sys_heap_aligned_realloc(struct sys_heap *heap, void *ptr, size_t align, size_t bytes); size_t sys_heap_usable_size(struct sys_heap *heap, void *mem); _Bool sys_heap_validate(struct sys_heap *heap); void sys_heap_stress(void *(*alloc_fn)(void *arg, size_t bytes), void (*free_fn)(void *arg, void *p), void *arg, size_t total_bytes, uint32_t op_count, void *scratch_mem, size_t scratch_bytes, int target_percent, struct z_heap_stress_result *result); void sys_heap_print_info(struct sys_heap *heap, _Bool dump_chunks); struct _cpu_arch { atomic_ptr_val_t fpu_owner; }; typedef struct _cpu_arch _cpu_arch_t; struct k_cycle_stats { uint64_t total; _Bool track_usage; }; struct _ready_q { struct k_thread *cache; sys_dlist_t runq; }; typedef struct _ready_q _ready_q_t; struct _cpu { uint32_t nested; char *irq_stack; struct k_thread *current; struct k_thread *idle_thread; uint8_t id; void *fp_ctx; struct _cpu_arch arch; }; typedef struct _cpu _cpu_t; struct z_kernel { struct _cpu cpus[1]; struct _ready_q ready_q; struct k_thread *current_fp; }; typedef struct z_kernel _kernel_t; extern struct z_kernel _kernel; extern atomic_t _cpus_active; typedef struct { sys_dlist_t waitq; } _wait_q_t; struct _timeout; typedef void (*_timeout_func_t)(struct _timeout *t); struct _timeout { sys_dnode_t node; _timeout_func_t fn; int64_t dticks; }; typedef void (*k_thread_timeslice_fn_t)(struct k_thread *thread, void *data); uint32_t sys_kernel_version_get(void); typedef int __gwchar_t; typedef struct { long int quot; long int rem; } imaxdiv_t; extern intmax_t imaxabs (intmax_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern intmax_t strtoimax (const char *__restrict __nptr, char **__restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__)); extern uintmax_t strtoumax (const char *__restrict __nptr, char ** __restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__)); extern intmax_t wcstoimax (const __gwchar_t *__restrict __nptr, __gwchar_t **__restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__)); extern uintmax_t wcstoumax (const __gwchar_t *__restrict __nptr, __gwchar_t ** __restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__)); __attribute__((format (printf, 1, 2))) void printk(const char *fmt, ...); __attribute__((format (printf, 1, 0))) void vprintk(const char *fmt, va_list ap); typedef struct { int __count; union { unsigned int __wch; char __wchb[4]; } __value; } __mbstate_t; typedef struct _G_fpos_t { __off_t __pos; __mbstate_t __state; } __fpos_t; typedef struct _G_fpos64_t { __off64_t __pos; __mbstate_t __state; } __fpos64_t; struct _IO_FILE; typedef struct _IO_FILE __FILE; struct _IO_FILE; typedef struct _IO_FILE FILE; struct _IO_FILE; struct _IO_marker; struct _IO_codecvt; struct _IO_wide_data; typedef void _IO_lock_t; struct _IO_FILE { int _flags; char *_IO_read_ptr; char *_IO_read_end; char *_IO_read_base; char *_IO_write_base; char *_IO_write_ptr; char *_IO_write_end; char *_IO_buf_base; char *_IO_buf_end; char *_IO_save_base; char *_IO_backup_base; char *_IO_save_end; struct _IO_marker *_markers; struct _IO_FILE *_chain; int _fileno; int _flags2; __off_t _old_offset; unsigned short _cur_column; signed char _vtable_offset; char _shortbuf[1]; _IO_lock_t *_lock; __off64_t _offset; struct _IO_codecvt *_codecvt; struct _IO_wide_data *_wide_data; struct _IO_FILE *_freeres_list; void *_freeres_buf; size_t __pad5; int _mode; char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)]; }; typedef __off_t off_t; typedef __ssize_t ssize_t; typedef __fpos_t fpos_t; extern FILE *stdin; extern FILE *stdout; extern FILE *stderr; extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__)); extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__)); extern int renameat (int __oldfd, const char *__old, int __newfd, const char *__new) __attribute__ ((__nothrow__ , __leaf__)); extern int fclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); extern FILE *tmpfile (void) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern char *tmpnam (char[20]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)); extern int fflush (FILE *__stream); extern FILE *fopen (const char *__restrict __filename, const char *__restrict __modes) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern FILE *freopen (const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (3))); extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__)); extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__)); extern int fprintf (FILE *__restrict __stream, const char *__restrict __format, ...); extern int printf (const char *__restrict __format, ...); extern int sprintf (char *__restrict __s, const char *__restrict __format, ...) __attribute__ ((__nothrow__)); extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg); extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); extern int vsprintf (char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__nothrow__)); extern int snprintf (char *__restrict __s, size_t __maxlen, const char *__restrict __format, ...) __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4))); extern int vsnprintf (char *__restrict __s, size_t __maxlen, const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0))); extern int vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __arg) __attribute__ ((__format__ (__printf__, 2, 0))); extern int dprintf (int __fd, const char *__restrict __fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3))); extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__)); extern int scanf (const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__)); extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__)); extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("__USER_LABEL_PREFIX__" "__isoc99_fscanf") __attribute__ ((__warn_unused_result__)); extern int scanf (const char *__restrict __format, ...) __asm__ ("__USER_LABEL_PREFIX__" "__isoc99_scanf") __attribute__ ((__warn_unused_result__)); extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __asm__ ("__USER_LABEL_PREFIX__" "__isoc99_sscanf") __attribute__ ((__nothrow__ , __leaf__)); extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__)); extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__)); extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0))); extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("__USER_LABEL_PREFIX__" "__isoc99_vfscanf") __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__)); extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("__USER_LABEL_PREFIX__" "__isoc99_vscanf") __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__)); extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("__USER_LABEL_PREFIX__" "__isoc99_vsscanf") __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0))); extern int fgetc (FILE *__stream); extern int getc (FILE *__stream); extern int getchar (void); extern int getc_unlocked (FILE *__stream); extern int getchar_unlocked (void); extern int fputc (int __c, FILE *__stream); extern int putc (int __c, FILE *__stream); extern int putchar (int __c); extern int putc_unlocked (int __c, FILE *__stream); extern int putchar_unlocked (int __c); extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__write_only__, 1, 2))); extern char *gets (char *__s) __attribute__ ((__warn_unused_result__)) __attribute__ ((__deprecated__)); extern __ssize_t __getdelim (char **__restrict __lineptr, size_t *__restrict __n, int __delimiter, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)); extern __ssize_t getdelim (char **__restrict __lineptr, size_t *__restrict __n, int __delimiter, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)); extern __ssize_t getline (char **__restrict __lineptr, size_t *__restrict __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)); extern int fputs (const char *__restrict __s, FILE *__restrict __stream); extern int puts (const char *__s); extern int ungetc (int __c, FILE *__stream); extern size_t fread (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)); extern size_t fwrite (const void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __s); extern int fseek (FILE *__stream, long int __off, int __whence); extern long int ftell (FILE *__stream) __attribute__ ((__warn_unused_result__)); extern void rewind (FILE *__stream); extern int fseeko (FILE *__stream, __off_t __off, int __whence); extern __off_t ftello (FILE *__stream) __attribute__ ((__warn_unused_result__)); extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos); extern int fsetpos (FILE *__stream, const fpos_t *__pos); extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)); extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)); extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)); extern void perror (const char *__s) __attribute__ ((__cold__)); extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)); extern int pclose (FILE *__stream); extern FILE *popen (const char *__command, const char *__modes) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (pclose, 1))) __attribute__ ((__warn_unused_result__)); extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__write_only__, 1))); extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)); extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)); extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)); extern int __uflow (FILE *); extern int __overflow (FILE *, int); extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen, const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__write_only__, 1, 3))); extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen, const char *__restrict __format, __gnuc_va_list __ap) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__write_only__, 1, 3))); extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag, size_t __slen, const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__write_only__, 1, 2))); extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag, size_t __slen, const char *__restrict __format, __gnuc_va_list __ap) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__write_only__, 1, 2))); extern char *__gets_warn (char *__str) __asm__ ("__USER_LABEL_PREFIX__" "gets") __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use fgets or getline instead, gets can't " "specify buffer size"))); extern char *__gets_chk (char *__str, size_t) __attribute__ ((__warn_unused_result__)); extern char *__fgets_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("__USER_LABEL_PREFIX__" "fgets") __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__write_only__, 1, 2))); extern char *__fgets_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("__USER_LABEL_PREFIX__" "__fgets_chk") __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets called with bigger size than length " "of destination buffer"))); extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__write_only__, 1, 3))); extern size_t __fread_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("__USER_LABEL_PREFIX__" "fread") __attribute__ ((__warn_unused_result__)); extern size_t __fread_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("__USER_LABEL_PREFIX__" "__fread_chk") __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread called with bigger size * nmemb than length " "of destination buffer"))); extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__nothrow__ , __leaf__)) sprintf (char *__restrict __s, const char *__restrict __fmt, ...) { return __builtin___sprintf_chk (__s, 1 - 1, __builtin_object_size (__s, 1 > 1), __fmt,); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__nothrow__ , __leaf__)) vsprintf (char *__restrict __s, const char *__restrict __fmt, __gnuc_va_list __ap) { return __builtin___vsprintf_chk (__s, 1 - 1, __builtin_object_size (__s, 1 > 1), __fmt, __ap); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__nothrow__ , __leaf__)) snprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, ...) { return __builtin___snprintf_chk (__s, __n, 1 - 1, __builtin_object_size (__s, 1 > 1), __fmt,); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__nothrow__ , __leaf__)) vsnprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, __gnuc_va_list __ap) { return __builtin___vsnprintf_chk (__s, __n, 1 - 1, __builtin_object_size (__s, 1 > 1), __fmt, __ap); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char * gets (char *__str) { if (__builtin_object_size (__str, 1 > 1) != (size_t) -1) return __gets_chk (__str, __builtin_object_size (__str, 1 > 1)); return __gets_warn (__str); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__write_only__, 1, 2))) char * fgets (char *__restrict __s, int __n, FILE *__restrict __stream) { size_t sz = __builtin_object_size (__s, 1 > 1); if (((__builtin_constant_p (sz) && (sz) == (unsigned long) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((unsigned long) (__n)) <= ((sz)) / ((sizeof (char))))) && (((unsigned long) (__n)) <= ((sz)) / ((sizeof (char))))))) return __fgets_alias (__s, __n, __stream); if ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((unsigned long) (__n)) <= (sz) / (sizeof (char)))) && !(((unsigned long) (__n)) <= (sz) / (sizeof (char))))) return __fgets_chk_warn (__s, sz, __n, __stream); return __fgets_chk (__s, sz, __n, __stream); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t fread (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) { size_t sz = __builtin_object_size (__ptr, 0); if (((__builtin_constant_p (sz) && (sz) == (unsigned long) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((unsigned long) (__n)) <= ((sz)) / ((__size)))) && (((unsigned long) (__n)) <= ((sz)) / ((__size)))))) return __fread_alias (__ptr, __size, __n, __stream); if ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((unsigned long) (__n)) <= (sz) / (__size))) && !(((unsigned long) (__n)) <= (sz) / (__size)))) return __fread_chk_warn (__ptr, sz, __size, __n, __stream); return __fread_chk (__ptr, sz, __size, __n, __stream); } typedef void (*irq_offload_routine_t)(const void *parameter); void irq_offload(irq_offload_routine_t routine, const void *parameter); struct k_thread; struct k_mem_domain; typedef struct z_thread_stack_element k_thread_stack_t; typedef void (*k_thread_entry_t)(void *p1, void *p2, void *p3); static inline uint32_t arch_k_cycle_get_32(void); static inline uint64_t arch_k_cycle_get_64(void); void arch_cpu_idle(void); void arch_cpu_atomic_idle(unsigned int key); typedef __attribute__((__noreturn__)) void (*arch_cpustart_t)(void *data); void arch_start_cpu(int cpu_num, k_thread_stack_t *stack, int sz, arch_cpustart_t fn, void *arg); _Bool arch_cpu_active(int cpu_num); static inline unsigned int arch_irq_lock(void); static inline void arch_irq_unlock(unsigned int key); static inline _Bool arch_irq_unlocked(unsigned int key); void arch_irq_disable(unsigned int irq); void arch_irq_enable(unsigned int irq); int arch_irq_is_enabled(unsigned int irq); int arch_irq_connect_dynamic(unsigned int irq, unsigned int priority, void (*routine)(const void *parameter), const void *parameter, uint32_t flags); int arch_irq_disconnect_dynamic(unsigned int irq, unsigned int priority, void (*routine)(const void *parameter), const void *parameter, uint32_t flags); unsigned int arch_irq_allocate(void); void arch_irq_set_used(unsigned int irq); _Bool arch_irq_is_used(unsigned int irq); static inline unsigned int arch_num_cpus(void); static inline _Bool arch_mem_coherent(void *ptr) { (void)(ptr); return 1; } static inline void arch_cohere_stacks(struct k_thread *old_thread, void *old_switch_handle, struct k_thread *new_thread) { (void)(old_thread); (void)(old_switch_handle); (void)(new_thread); } void arch_spin_relax(void); static inline __attribute__((always_inline)) uint64_t read_ccsidr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "ccsidr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_ccsidr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "ccsidr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_ccsidr_el1(void) { ({ __asm__ volatile ("msr " "ccsidr_el1" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_clidr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "clidr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_clidr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "clidr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_clidr_el1(void) { ({ __asm__ volatile ("msr " "clidr_el1" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_cntfrq_el0(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cntfrq_el0" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cntfrq_el0(uint64_t val) { ({ __asm__ volatile ("msr " "cntfrq_el0" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cntfrq_el0(void) { ({ __asm__ volatile ("msr " "cntfrq_el0" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_cnthctl_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cnthctl_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cnthctl_el2(uint64_t val) { ({ __asm__ volatile ("msr " "cnthctl_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cnthctl_el2(void) { ({ __asm__ volatile ("msr " "cnthctl_el2" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_cnthp_ctl_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cnthp_ctl_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cnthp_ctl_el2(uint64_t val) { ({ __asm__ volatile ("msr " "cnthp_ctl_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cnthp_ctl_el2(void) { ({ __asm__ volatile ("msr " "cnthp_ctl_el2" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_cnthps_ctl_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cnthps_ctl_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cnthps_ctl_el2(uint64_t val) { ({ __asm__ volatile ("msr " "cnthps_ctl_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cnthps_ctl_el2(void) { ({ __asm__ volatile ("msr " "cnthps_ctl_el2" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_cntv_ctl_el0(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cntv_ctl_el0" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cntv_ctl_el0(uint64_t val) { ({ __asm__ volatile ("msr " "cntv_ctl_el0" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cntv_ctl_el0(void) { ({ __asm__ volatile ("msr " "cntv_ctl_el0" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_cntv_cval_el0(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cntv_cval_el0" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cntv_cval_el0(uint64_t val) { ({ __asm__ volatile ("msr " "cntv_cval_el0" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cntv_cval_el0(void) { ({ __asm__ volatile ("msr " "cntv_cval_el0" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_cntvct_el0(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cntvct_el0" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cntvct_el0(uint64_t val) { ({ __asm__ volatile ("msr " "cntvct_el0" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cntvct_el0(void) { ({ __asm__ volatile ("msr " "cntvct_el0" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_cntvoff_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cntvoff_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cntvoff_el2(uint64_t val) { ({ __asm__ volatile ("msr " "cntvoff_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cntvoff_el2(void) { ({ __asm__ volatile ("msr " "cntvoff_el2" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_currentel(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "currentel" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_currentel(uint64_t val) { ({ __asm__ volatile ("msr " "currentel" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_currentel(void) { ({ __asm__ volatile ("msr " "currentel" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_csselr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "csselr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_csselr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "csselr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_csselr_el1(void) { ({ __asm__ volatile ("msr " "csselr_el1" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_daif(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "daif" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_daif(uint64_t val) { ({ __asm__ volatile ("msr " "daif" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_daif(void) { ({ __asm__ volatile ("msr " "daif" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_hcr_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "hcr_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_hcr_el2(uint64_t val) { ({ __asm__ volatile ("msr " "hcr_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_hcr_el2(void) { ({ __asm__ volatile ("msr " "hcr_el2" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_id_aa64pfr0_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "id_aa64pfr0_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_id_aa64pfr0_el1(uint64_t val) { ({ __asm__ volatile ("msr " "id_aa64pfr0_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_id_aa64pfr0_el1(void) { ({ __asm__ volatile ("msr " "id_aa64pfr0_el1" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_id_aa64mmfr0_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "id_aa64mmfr0_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_id_aa64mmfr0_el1(uint64_t val) { ({ __asm__ volatile ("msr " "id_aa64mmfr0_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_id_aa64mmfr0_el1(void) { ({ __asm__ volatile ("msr " "id_aa64mmfr0_el1" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_mpidr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "mpidr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_mpidr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "mpidr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_mpidr_el1(void) { ({ __asm__ volatile ("msr " "mpidr_el1" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_par_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "par_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_par_el1(uint64_t val) { ({ __asm__ volatile ("msr " "par_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_par_el1(void) { ({ __asm__ volatile ("msr " "par_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_scr_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "scr_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_scr_el3(uint64_t val) { ({ __asm__ volatile ("msr " "scr_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_scr_el3(void) { ({ __asm__ volatile ("msr " "scr_el3" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_tpidrro_el0(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "tpidrro_el0" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_tpidrro_el0(uint64_t val) { ({ __asm__ volatile ("msr " "tpidrro_el0" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_tpidrro_el0(void) { ({ __asm__ volatile ("msr " "tpidrro_el0" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_vmpidr_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "vmpidr_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_vmpidr_el2(uint64_t val) { ({ __asm__ volatile ("msr " "vmpidr_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_vmpidr_el2(void) { ({ __asm__ volatile ("msr " "vmpidr_el2" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_sp_el0(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "sp_el0" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_sp_el0(uint64_t val) { ({ __asm__ volatile ("msr " "sp_el0" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_sp_el0(void) { ({ __asm__ volatile ("msr " "sp_el0" ", xzr" ::: "memory"); }); }; static inline __attribute__((always_inline)) uint64_t read_actlr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "actlr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_actlr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "actlr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_actlr_el1(void) { ({ __asm__ volatile ("msr " "actlr_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_actlr_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "actlr_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_actlr_el2(uint64_t val) { ({ __asm__ volatile ("msr " "actlr_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_actlr_el2(void) { ({ __asm__ volatile ("msr " "actlr_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_actlr_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "actlr_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_actlr_el3(uint64_t val) { ({ __asm__ volatile ("msr " "actlr_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_actlr_el3(void) { ({ __asm__ volatile ("msr " "actlr_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_cpacr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cpacr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cpacr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "cpacr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cpacr_el1(void) { ({ __asm__ volatile ("msr " "cpacr_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_cpacr_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cpacr_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cpacr_el2(uint64_t val) { ({ __asm__ volatile ("msr " "cpacr_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cpacr_el2(void) { ({ __asm__ volatile ("msr " "cpacr_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_cpacr_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cpacr_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cpacr_el3(uint64_t val) { ({ __asm__ volatile ("msr " "cpacr_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cpacr_el3(void) { ({ __asm__ volatile ("msr " "cpacr_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_cptr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cptr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cptr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "cptr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cptr_el1(void) { ({ __asm__ volatile ("msr " "cptr_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_cptr_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cptr_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cptr_el2(uint64_t val) { ({ __asm__ volatile ("msr " "cptr_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cptr_el2(void) { ({ __asm__ volatile ("msr " "cptr_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_cptr_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "cptr_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_cptr_el3(uint64_t val) { ({ __asm__ volatile ("msr " "cptr_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_cptr_el3(void) { ({ __asm__ volatile ("msr " "cptr_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_elr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "elr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_elr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "elr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_elr_el1(void) { ({ __asm__ volatile ("msr " "elr_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_elr_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "elr_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_elr_el2(uint64_t val) { ({ __asm__ volatile ("msr " "elr_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_elr_el2(void) { ({ __asm__ volatile ("msr " "elr_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_elr_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "elr_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_elr_el3(uint64_t val) { ({ __asm__ volatile ("msr " "elr_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_elr_el3(void) { ({ __asm__ volatile ("msr " "elr_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_esr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "esr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_esr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "esr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_esr_el1(void) { ({ __asm__ volatile ("msr " "esr_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_esr_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "esr_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_esr_el2(uint64_t val) { ({ __asm__ volatile ("msr " "esr_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_esr_el2(void) { ({ __asm__ volatile ("msr " "esr_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_esr_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "esr_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_esr_el3(uint64_t val) { ({ __asm__ volatile ("msr " "esr_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_esr_el3(void) { ({ __asm__ volatile ("msr " "esr_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_far_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "far_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_far_el1(uint64_t val) { ({ __asm__ volatile ("msr " "far_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_far_el1(void) { ({ __asm__ volatile ("msr " "far_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_far_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "far_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_far_el2(uint64_t val) { ({ __asm__ volatile ("msr " "far_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_far_el2(void) { ({ __asm__ volatile ("msr " "far_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_far_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "far_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_far_el3(uint64_t val) { ({ __asm__ volatile ("msr " "far_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_far_el3(void) { ({ __asm__ volatile ("msr " "far_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_mair_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "mair_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_mair_el1(uint64_t val) { ({ __asm__ volatile ("msr " "mair_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_mair_el1(void) { ({ __asm__ volatile ("msr " "mair_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_mair_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "mair_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_mair_el2(uint64_t val) { ({ __asm__ volatile ("msr " "mair_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_mair_el2(void) { ({ __asm__ volatile ("msr " "mair_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_mair_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "mair_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_mair_el3(uint64_t val) { ({ __asm__ volatile ("msr " "mair_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_mair_el3(void) { ({ __asm__ volatile ("msr " "mair_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_sctlr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "sctlr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_sctlr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "sctlr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_sctlr_el1(void) { ({ __asm__ volatile ("msr " "sctlr_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_sctlr_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "sctlr_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_sctlr_el2(uint64_t val) { ({ __asm__ volatile ("msr " "sctlr_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_sctlr_el2(void) { ({ __asm__ volatile ("msr " "sctlr_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_sctlr_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "sctlr_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_sctlr_el3(uint64_t val) { ({ __asm__ volatile ("msr " "sctlr_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_sctlr_el3(void) { ({ __asm__ volatile ("msr " "sctlr_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_spsr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "spsr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_spsr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "spsr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_spsr_el1(void) { ({ __asm__ volatile ("msr " "spsr_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_spsr_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "spsr_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_spsr_el2(uint64_t val) { ({ __asm__ volatile ("msr " "spsr_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_spsr_el2(void) { ({ __asm__ volatile ("msr " "spsr_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_spsr_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "spsr_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_spsr_el3(uint64_t val) { ({ __asm__ volatile ("msr " "spsr_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_spsr_el3(void) { ({ __asm__ volatile ("msr " "spsr_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_tcr_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "tcr_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_tcr_el1(uint64_t val) { ({ __asm__ volatile ("msr " "tcr_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_tcr_el1(void) { ({ __asm__ volatile ("msr " "tcr_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_tcr_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "tcr_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_tcr_el2(uint64_t val) { ({ __asm__ volatile ("msr " "tcr_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_tcr_el2(void) { ({ __asm__ volatile ("msr " "tcr_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_tcr_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "tcr_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_tcr_el3(uint64_t val) { ({ __asm__ volatile ("msr " "tcr_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_tcr_el3(void) { ({ __asm__ volatile ("msr " "tcr_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_ttbr0_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "ttbr0_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_ttbr0_el1(uint64_t val) { ({ __asm__ volatile ("msr " "ttbr0_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_ttbr0_el1(void) { ({ __asm__ volatile ("msr " "ttbr0_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_ttbr0_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "ttbr0_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_ttbr0_el2(uint64_t val) { ({ __asm__ volatile ("msr " "ttbr0_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_ttbr0_el2(void) { ({ __asm__ volatile ("msr " "ttbr0_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_ttbr0_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "ttbr0_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_ttbr0_el3(uint64_t val) { ({ __asm__ volatile ("msr " "ttbr0_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_ttbr0_el3(void) { ({ __asm__ volatile ("msr " "ttbr0_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_vbar_el1(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "vbar_el1" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_vbar_el1(uint64_t val) { ({ __asm__ volatile ("msr " "vbar_el1" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_vbar_el1(void) { ({ __asm__ volatile ("msr " "vbar_el1" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_vbar_el2(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "vbar_el2" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_vbar_el2(uint64_t val) { ({ __asm__ volatile ("msr " "vbar_el2" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_vbar_el2(void) { ({ __asm__ volatile ("msr " "vbar_el2" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) uint64_t read_vbar_el3(void) { return ({ uint64_t reg_val; __asm__ volatile ("mrs %0, " "vbar_el3" : "=r" (reg_val) :: "memory"); reg_val; }); } static inline __attribute__((always_inline)) void write_vbar_el3(uint64_t val) { ({ __asm__ volatile ("msr " "vbar_el3" ", %0" :: "r" (val) : "memory"); }); } static inline __attribute__((always_inline)) void zero_vbar_el3(void) { ({ __asm__ volatile ("msr " "vbar_el3" ", xzr" ::: "memory"); }); } static inline __attribute__((always_inline)) void enable_debug_exceptions(void) { __asm__ volatile ("msr DAIFClr, %0" :: "i" ((1UL << (3))) : "memory"); } static inline __attribute__((always_inline)) void disable_debug_exceptions(void) { __asm__ volatile ("msr DAIFSet, %0" :: "i" ((1UL << (3))) : "memory"); } static inline __attribute__((always_inline)) void enable_serror_exceptions(void) { __asm__ volatile ("msr DAIFClr, %0" :: "i" ((1UL << (2))) : "memory"); } static inline __attribute__((always_inline)) void disable_serror_exceptions(void) { __asm__ volatile ("msr DAIFSet, %0" :: "i" ((1UL << (2))) : "memory"); } static inline __attribute__((always_inline)) void enable_irq(void) { __asm__ volatile ("msr DAIFClr, %0" :: "i" ((1UL << (1))) : "memory"); } static inline __attribute__((always_inline)) void disable_irq(void) { __asm__ volatile ("msr DAIFSet, %0" :: "i" ((1UL << (1))) : "memory"); } static inline __attribute__((always_inline)) void enable_fiq(void) { __asm__ volatile ("msr DAIFClr, %0" :: "i" ((1UL << (0))) : "memory"); } static inline __attribute__((always_inline)) void disable_fiq(void) { __asm__ volatile ("msr DAIFSet, %0" :: "i" ((1UL << (0))) : "memory"); } static inline _Bool is_el_implemented(unsigned int el) { unsigned int shift; if (el > 3) { return 0; } shift = (4) * el; return (((read_id_aa64pfr0_el1() >> shift) & (0xf)) != 0U); } static inline _Bool is_el_highest_implemented(void) { uint32_t el_highest; uint32_t curr_el; el_highest = read_id_aa64pfr0_el1() & 0xFFFF; el_highest = (31U - __builtin_clz(el_highest)) / 4; curr_el = (((read_currentel()) >> (0x2)) & (0x3)); if (curr_el < el_highest) return 0; return 1; } static inline _Bool is_el2_sec_supported(void) { return (((read_id_aa64pfr0_el1() >> (36)) & (0xf)) != 0U); } static inline _Bool is_in_secure_state(void) { return !0; } static inline __attribute__((always_inline)) _cpu_t *arch_curr_cpu(void) { return (_cpu_t *)(read_tpidrro_el0() & 0x0000fffffffffff8); } static inline __attribute__((always_inline)) int arch_exception_depth(void) { return (read_tpidrro_el0() & 0xff00000000000000) / 0x0100000000000000; } static inline __attribute__((always_inline)) uint32_t arch_proc_id(void) { uint64_t cpu_mpid = read_mpidr_el1(); { }; return (uint32_t)cpu_mpid; } static inline __attribute__((always_inline)) unsigned int arch_num_cpus(void) { return 1; } typedef struct { int quot; int rem; } div_t; typedef struct { long int quot; long int rem; } ldiv_t; typedef struct { long long int quot; long long int rem; } lldiv_t; extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)); extern double atof (const char *__nptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern int atoi (const char *__nptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern long int atol (const char *__nptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern long long int atoll (const char *__nptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern double strtod (const char *__restrict __nptr, char **__restrict __endptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); extern float strtof (const char *__restrict __nptr, char **__restrict __endptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); extern long double strtold (const char *__restrict __nptr, char **__restrict __endptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); extern int rand (void) __attribute__ ((__nothrow__ , __leaf__)); extern void srand (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__)); extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__ , __leaf__)); extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1))) __attribute__ ((__warn_unused_result__)); extern void *calloc (size_t __nmemb, size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) __attribute__ ((__warn_unused_result__)); extern void *realloc (void *__ptr, size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2))); extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__)); extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern void abort (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__)); extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); extern void exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__)); extern void _Exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__)); extern char *getenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern int setenv (const char *__name, const char *__value, int __replace) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))); extern int unsetenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern int system (const char *__command) __attribute__ ((__warn_unused_result__)); typedef int (*__compar_fn_t) (const void *, const void *); extern void *bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 2, 5))) __attribute__ ((__warn_unused_result__)); extern void qsort (void *__base, size_t __nmemb, size_t __size, __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); extern int abs (int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); extern long int labs (long int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); extern long long int llabs (long long int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); extern div_t div (int __numer, int __denom) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); extern ldiv_t ldiv (long int __numer, long int __denom) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); extern lldiv_t lldiv (long long int __numer, long long int __denom) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); extern int mblen (const char *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)); extern int mbtowc (wchar_t *__restrict __pwc, const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)); extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__ , __leaf__)); extern size_t mbstowcs (wchar_t *__restrict __pwcs, const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__read_only__, 2))); extern size_t wcstombs (char *__restrict __s, const wchar_t *__restrict __pwcs, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__access__ (__read_only__, 2))); extern int getsubopt (char **__restrict __optionp, char *const *__restrict __tokens, char **__restrict __valuep) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__warn_unused_result__)); extern char *__realpath_chk (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)); extern char *__realpath_alias (const char *__restrict __name, char *__restrict __resolved) __asm__ ("__USER_LABEL_PREFIX__" "realpath") __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)); extern char *__realpath_chk_warn (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) __asm__ ("__USER_LABEL_PREFIX__" "__realpath_chk") __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer"))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char * __attribute__ ((__nothrow__ , __leaf__)) realpath (const char *__restrict __name, char *__restrict __resolved) { size_t sz = __builtin_object_size (__resolved, 1 > 1); if (sz == (size_t) -1) return __realpath_alias (__name, __resolved); if ((((__typeof (4096)) 0 < (__typeof (4096)) -1 || (__builtin_constant_p (4096) && (4096) > 0)) && __builtin_constant_p ((((unsigned long) (4096)) <= (sz) / (sizeof (char)))) && !(((unsigned long) (4096)) <= (sz) / (sizeof (char))))) return __realpath_chk_warn (__name, __resolved, sz); return __realpath_chk (__name, __resolved, sz); } extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen, size_t __nreal) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) __asm__ ("__USER_LABEL_PREFIX__" "ptsname_r") __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) __asm__ ("__USER_LABEL_PREFIX__" "__ptsname_r_chk") __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf"))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__nothrow__ , __leaf__)) ptsname_r (int __fd, char *__buf, size_t __buflen) { return (((__builtin_constant_p (__builtin_object_size (__buf, 1 > 1)) && (__builtin_object_size (__buf, 1 > 1)) == (unsigned long) -1) || (((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__builtin_constant_p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((unsigned long) (__buflen)) <= ((__builtin_object_size (__buf, 1 > 1))) / ((sizeof (char))))) && (((unsigned long) (__buflen)) <= ((__builtin_object_size (__buf, 1 > 1))) / ((sizeof (char)))))) ? __ptsname_r_alias (__fd, __buf, __buflen) : ((((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__builtin_constant_p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((unsigned long) (__buflen)) <= (__builtin_object_size (__buf, 1 > 1)) / (sizeof (char)))) && !(((unsigned long) (__buflen)) <= (__builtin_object_size (__buf, 1 > 1)) / (sizeof (char)))) ? __ptsname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 1 > 1)) : __ptsname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 1 > 1)))); } extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)); extern int __wctomb_alias (char *__s, wchar_t __wchar) __asm__ ("__USER_LABEL_PREFIX__" "wctomb") __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) int __attribute__ ((__nothrow__ , __leaf__)) wctomb (char *__s, wchar_t __wchar) { if (__builtin_object_size (__s, 1 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 1 > 1)) return __wctomb_chk (__s, __wchar, __builtin_object_size (__s, 1 > 1)); return __wctomb_alias (__s, __wchar); } extern size_t __mbstowcs_chk (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__access__ (__read_only__, 2))); extern size_t __mbstowcs_nulldst (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) __asm__ ("__USER_LABEL_PREFIX__" "mbstowcs") __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__read_only__, 2))); extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) __asm__ ("__USER_LABEL_PREFIX__" "mbstowcs") __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__access__ (__read_only__, 2))); extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen) __asm__ ("__USER_LABEL_PREFIX__" "__mbstowcs_chk") __attribute__ ((__nothrow__ , __leaf__)) __attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)"))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__nothrow__ , __leaf__)) mbstowcs (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) { if (__builtin_constant_p (__dst == ((void *)0)) && __dst == ((void *)0)) return __mbstowcs_nulldst (__dst, __src, __len); else return (((__builtin_constant_p (__builtin_object_size (__dst, 1 > 1)) && (__builtin_object_size (__dst, 1 > 1)) == (unsigned long) -1) || (((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((unsigned long) (__len)) <= ((__builtin_object_size (__dst, 1 > 1))) / ((sizeof (wchar_t))))) && (((unsigned long) (__len)) <= ((__builtin_object_size (__dst, 1 > 1))) / ((sizeof (wchar_t)))))) ? __mbstowcs_alias (__dst, __src, __len) : ((((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((unsigned long) (__len)) <= (__builtin_object_size (__dst, 1 > 1)) / (sizeof (wchar_t)))) && !(((unsigned long) (__len)) <= (__builtin_object_size (__dst, 1 > 1)) / (sizeof (wchar_t)))) ? __mbstowcs_chk_warn (__dst, __src, __len, (__builtin_object_size (__dst, 1 > 1)) / (sizeof (wchar_t))) : __mbstowcs_chk (__dst, __src, __len, (__builtin_object_size (__dst, 1 > 1)) / (sizeof (wchar_t))))); } extern size_t __wcstombs_chk (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__access__ (__read_only__, 2))); extern size_t __wcstombs_alias (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) __asm__ ("__USER_LABEL_PREFIX__" "wcstombs") __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__access__ (__read_only__, 2))); extern size_t __wcstombs_chk_warn (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen) __asm__ ("__USER_LABEL_PREFIX__" "__wcstombs_chk") __attribute__ ((__nothrow__ , __leaf__)) __attribute__((__warning__ ("wcstombs called with dst buffer smaller than len"))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__nothrow__ , __leaf__)) wcstombs (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) { return (((__builtin_constant_p (__builtin_object_size (__dst, 1 > 1)) && (__builtin_object_size (__dst, 1 > 1)) == (unsigned long) -1) || (((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((unsigned long) (__len)) <= ((__builtin_object_size (__dst, 1 > 1))) / ((sizeof (char))))) && (((unsigned long) (__len)) <= ((__builtin_object_size (__dst, 1 > 1))) / ((sizeof (char)))))) ? __wcstombs_alias (__dst, __src, __len) : ((((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((unsigned long) (__len)) <= (__builtin_object_size (__dst, 1 > 1)) / (sizeof (char)))) && !(((unsigned long) (__len)) <= (__builtin_object_size (__dst, 1 > 1)) / (sizeof (char)))) ? __wcstombs_chk_warn (__dst, __src, __len, __builtin_object_size (__dst, 1 > 1)) : __wcstombs_chk (__dst, __src, __len, __builtin_object_size (__dst, 1 > 1)))); } struct arm_mmu_region { uintptr_t base_pa; uintptr_t base_va; size_t size; const char *name; uint32_t attrs; }; struct arm_mmu_config { unsigned int num_regions; const struct arm_mmu_region *mmu_regions; }; struct arm_mmu_ptables { uint64_t *base_xlat_table; uint64_t ttbr0; }; typedef struct { uint32_t attrs; } k_mem_partition_attr_t; extern const struct arm_mmu_config mmu_config; struct k_thread; void z_arm64_thread_mem_domains_init(struct k_thread *thread); void z_arm64_swap_mem_domains(struct k_thread *thread); struct _callee_saved { uint64_t x19; uint64_t x20; uint64_t x21; uint64_t x22; uint64_t x23; uint64_t x24; uint64_t x25; uint64_t x26; uint64_t x27; uint64_t x28; uint64_t x29; uint64_t sp_el0; uint64_t sp_elx; uint64_t lr; }; typedef struct _callee_saved _callee_saved_t; struct z_arm64_fp_context { __int128 q0, q1, q2, q3, q4, q5, q6, q7; __int128 q8, q9, q10, q11, q12, q13, q14, q15; __int128 q16, q17, q18, q19, q20, q21, q22, q23; __int128 q24, q25, q26, q27, q28, q29, q30, q31; uint32_t fpsr, fpcr; }; struct _thread_arch { struct z_arm64_fp_context saved_fp_context; uint8_t exception_depth; }; typedef struct _thread_arch _thread_arch_t; struct __esf { uint64_t x0; uint64_t x1; uint64_t x2; uint64_t x3; uint64_t x4; uint64_t x5; uint64_t x6; uint64_t x7; uint64_t x8; uint64_t x9; uint64_t x10; uint64_t x11; uint64_t x12; uint64_t x13; uint64_t x14; uint64_t x15; uint64_t x16; uint64_t x17; uint64_t x18; uint64_t lr; uint64_t spsr; uint64_t elr; } __attribute__((__aligned__(16))); typedef struct __esf z_arch_esf_t; static inline int irq_connect_dynamic(unsigned int irq, unsigned int priority, void (*routine)(const void *parameter), const void *parameter, uint32_t flags) { return arch_irq_connect_dynamic(irq, priority, routine, parameter, flags); } static inline int irq_disconnect_dynamic(unsigned int irq, unsigned int priority, void (*routine)(const void *parameter), const void *parameter, uint32_t flags) { return arch_irq_disconnect_dynamic(irq, priority, routine, parameter, flags); } struct device; union init_function { int (*sys)(void); int (*dev)(const struct device *dev); }; struct init_entry { union init_function init_fn; union { const struct device *dev; }; }; _Bool sys_mm_is_phys_addr_in_range(uintptr_t phys); _Bool sys_mm_is_virt_addr_in_range(void *virt); static inline uintptr_t z_mem_phys_addr(void *virt) { uintptr_t addr = (uintptr_t)virt; { }; return ((addr) - ((0x200000 + 0x0) - (0x200000 + 0x0))); } static inline void *z_mem_virt_addr(uintptr_t phys) { { }; return (void *)((phys) + ((0x200000 + 0x0) - (0x200000 + 0x0))); } void z_phys_map(uint8_t **virt_ptr, uintptr_t phys, size_t size, uint32_t flags); void z_phys_unmap(uint8_t *virt, size_t size); size_t k_mem_free_get(void); void *k_mem_map(size_t size, uint32_t flags); void k_mem_unmap(void *addr, size_t size); size_t k_mem_region_align(uintptr_t *aligned_addr, size_t *aligned_size, uintptr_t addr, size_t size, size_t align); typedef uint32_t io_port_t; typedef uintptr_t mm_reg_t; typedef uintptr_t mem_addr_t; struct z_device_mmio_rom { uintptr_t phys_addr; size_t size; }; static inline void device_map(mm_reg_t *virt_addr, uintptr_t phys_addr, size_t size, uint32_t flags) { z_phys_map((uint8_t **)virt_addr, phys_addr, size, flags | (1UL << (3))); } typedef int16_t device_handle_t; struct device_state { uint8_t init_res; _Bool initialized : 1; }; struct pm_device; struct device { const char *name; const void *config; const void *api; struct device_state *state; void *data; }; static inline device_handle_t device_handle_get(const struct device *dev) { device_handle_t ret = 0; extern struct device _device_list_start[]; if (dev != ((void *)0)) { ret = 1 + (device_handle_t)(dev - _device_list_start); } return ret; } static inline const struct device * device_from_handle(device_handle_t dev_handle) { extern struct device _device_list_start[]; const struct device *dev = ((void *)0); size_t numdev; do { extern struct device _device_list_start[]; extern struct device _device_list_end[]; *(&numdev) = ((uintptr_t)_device_list_end - (uintptr_t)_device_list_start) / sizeof(struct device); } while (0);; if ((dev_handle > 0) && ((size_t)dev_handle <= numdev)) { dev = &_device_list_start[dev_handle - 1]; } return dev; } static inline const struct device *device_get_binding(const char *name); size_t z_device_get_all_static(const struct device **devices); _Bool z_device_is_ready(const struct device *dev); static inline _Bool device_is_ready(const struct device *dev); static inline _Bool z_impl_device_is_ready(const struct device *dev) { return z_device_is_ready(dev); } extern const struct device __device_dts_ord_0; extern const struct device __device_dts_ord_2; extern const struct device __device_dts_ord_1; extern const struct device __device_dts_ord_3; extern const struct device __device_dts_ord_12; extern const struct device __device_dts_ord_4; extern const struct device __device_dts_ord_8; extern const struct device __device_dts_ord_9; extern const struct device __device_dts_ord_13; extern const struct device __device_dts_ord_6; extern const struct device __device_dts_ord_7; extern const struct device __device_dts_ord_5; extern const struct device __device_dts_ord_10; extern const struct device __device_dts_ord_11; extern const struct device * z_impl_device_get_binding(const char * name); static inline const struct device * device_get_binding(const char * name) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_device_get_binding(name); } extern _Bool z_impl_device_is_ready(const struct device * dev); static inline _Bool device_is_ready(const struct device * dev) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_device_is_ready(dev); } void _isr_wrapper(void); void z_irq_spurious(const void *unused); struct _isr_table_entry { const void *arg; void (*isr)(const void *); }; extern struct _isr_table_entry _sw_isr_table[]; struct _irq_parent_entry { const struct device *dev; unsigned int irq; unsigned int offset; }; struct _isr_list { int32_t irq; int32_t flags; void *func; const void *param; }; extern void arch_irq_enable(unsigned int irq); extern void arch_irq_disable(unsigned int irq); extern int arch_irq_is_enabled(unsigned int irq); extern void z_arm64_irq_priority_set(unsigned int irq, unsigned int prio, uint32_t flags); extern void z_arm64_interrupt_init(void); extern uint32_t sys_clock_cycle_get_32(void); static inline uint32_t arch_k_cycle_get_32(void) { return sys_clock_cycle_get_32(); } extern uint64_t sys_clock_cycle_get_64(void); static inline uint64_t arch_k_cycle_get_64(void) { return sys_clock_cycle_get_64(); } static inline __attribute__((always_inline)) void arch_nop(void) { __asm__ volatile("nop"); } static inline __attribute__((always_inline)) unsigned int arch_irq_lock(void) { unsigned int key; key = read_daif(); disable_irq(); return key; } static inline __attribute__((always_inline)) void arch_irq_unlock(unsigned int key) { write_daif(key); } static inline __attribute__((always_inline)) _Bool arch_irq_unlocked(unsigned int key) { return (key & (1UL << (7))) == 0; } static inline __attribute__((always_inline)) void z_barrier_dmem_fence_full(void) { __asm__ volatile ("dmb sy" ::: "memory"); } static inline __attribute__((always_inline)) void z_barrier_dsync_fence_full(void) { __asm__ volatile ("dsb sy" ::: "memory"); } static inline __attribute__((always_inline)) void z_barrier_isync_fence_full(void) { __asm__ volatile ("isb" ::: "memory"); } static inline __attribute__((always_inline)) void barrier_dmem_fence_full(void) { z_barrier_dmem_fence_full(); } static inline __attribute__((always_inline)) void barrier_dsync_fence_full(void) { z_barrier_dsync_fence_full(); } static inline __attribute__((always_inline)) void barrier_isync_fence_full(void) { z_barrier_isync_fence_full(); } static inline __attribute__((always_inline)) uint8_t sys_read8(mem_addr_t addr) { uint8_t val; __asm__ volatile("ldrb %w0, [%1]" : "=r" (val) : "r" (addr)); barrier_dmem_fence_full(); return val; } static inline __attribute__((always_inline)) void sys_write8(uint8_t data, mem_addr_t addr) { barrier_dmem_fence_full(); __asm__ volatile("strb %w0, [%1]" : : "r" (data), "r" (addr)); } static inline __attribute__((always_inline)) uint16_t sys_read16(mem_addr_t addr) { uint16_t val; __asm__ volatile("ldrh %w0, [%1]" : "=r" (val) : "r" (addr)); barrier_dmem_fence_full(); return val; } static inline __attribute__((always_inline)) void sys_write16(uint16_t data, mem_addr_t addr) { barrier_dmem_fence_full(); __asm__ volatile("strh %w0, [%1]" : : "r" (data), "r" (addr)); } static inline __attribute__((always_inline)) uint32_t sys_read32(mem_addr_t addr) { uint32_t val; __asm__ volatile("ldr %w0, [%1]" : "=r" (val) : "r" (addr)); barrier_dmem_fence_full(); return val; } static inline __attribute__((always_inline)) void sys_write32(uint32_t data, mem_addr_t addr) { barrier_dmem_fence_full(); __asm__ volatile("str %w0, [%1]" : : "r" (data), "r" (addr)); } static inline __attribute__((always_inline)) uint64_t sys_read64(mem_addr_t addr) { uint64_t val; __asm__ volatile("ldr %x0, [%1]" : "=r" (val) : "r" (addr)); barrier_dmem_fence_full(); return val; } static inline __attribute__((always_inline)) void sys_write64(uint64_t data, mem_addr_t addr) { barrier_dmem_fence_full(); __asm__ volatile("str %x0, [%1]" : : "r" (data), "r" (addr)); } static inline __attribute__((always_inline)) void arm_arch_timer_init(void) { extern int z_clock_hw_cycles_per_sec; uint64_t cntfrq_el0 = read_cntfrq_el0(); { }; z_clock_hw_cycles_per_sec = (int) cntfrq_el0; } static inline __attribute__((always_inline)) void arm_arch_timer_set_compare(uint64_t val) { write_cntv_cval_el0(val); } static inline __attribute__((always_inline)) void arm_arch_timer_enable(unsigned char enable) { uint64_t cntv_ctl; cntv_ctl = read_cntv_ctl_el0(); if (enable) { cntv_ctl |= (1UL << (0)); } else { cntv_ctl &= ~(1UL << (0)); } write_cntv_ctl_el0(cntv_ctl); } static inline __attribute__((always_inline)) void arm_arch_timer_set_irq_mask(_Bool mask) { uint64_t cntv_ctl; cntv_ctl = read_cntv_ctl_el0(); if (mask) { cntv_ctl |= (1UL << (1)); } else { cntv_ctl &= ~(1UL << (1)); } write_cntv_ctl_el0(cntv_ctl); } static inline __attribute__((always_inline)) uint64_t arm_arch_timer_count(void) { return read_cntvct_el0(); } struct z_arm64_thread_stack_header { char privilege_stack[4096]; } __attribute__((__packed__)) __attribute__((__aligned__(16))); typedef uintptr_t paddr_t; typedef void *vaddr_t; static inline __attribute__((always_inline)) void sys_set_bit(mem_addr_t addr, unsigned int bit) { uint32_t temp = *(volatile uint32_t *)addr; *(volatile uint32_t *)addr = temp | (1 << bit); } static inline __attribute__((always_inline)) void sys_clear_bit(mem_addr_t addr, unsigned int bit) { uint32_t temp = *(volatile uint32_t *)addr; *(volatile uint32_t *)addr = temp & ~(1 << bit); } static inline __attribute__((always_inline)) int sys_test_bit(mem_addr_t addr, unsigned int bit) { uint32_t temp = *(volatile uint32_t *)addr; return temp & (1 << bit); } static inline __attribute__((always_inline)) void sys_set_bits(mem_addr_t addr, unsigned int mask) { uint32_t temp = *(volatile uint32_t *)addr; *(volatile uint32_t *)addr = temp | mask; } static inline __attribute__((always_inline)) void sys_clear_bits(mem_addr_t addr, unsigned int mask) { uint32_t temp = *(volatile uint32_t *)addr; *(volatile uint32_t *)addr = temp & ~mask; } static inline __attribute__((always_inline)) void sys_bitfield_set_bit(mem_addr_t addr, unsigned int bit) { sys_set_bit(addr + ((bit >> 5) << 2), bit & 0x1F); } static inline __attribute__((always_inline)) void sys_bitfield_clear_bit(mem_addr_t addr, unsigned int bit) { sys_clear_bit(addr + ((bit >> 5) << 2), bit & 0x1F); } static inline __attribute__((always_inline)) int sys_bitfield_test_bit(mem_addr_t addr, unsigned int bit) { return sys_test_bit(addr + ((bit >> 5) << 2), bit & 0x1F); } static inline __attribute__((always_inline)) int sys_test_and_set_bit(mem_addr_t addr, unsigned int bit) { int ret; ret = sys_test_bit(addr, bit); sys_set_bit(addr, bit); return ret; } static inline __attribute__((always_inline)) int sys_test_and_clear_bit(mem_addr_t addr, unsigned int bit) { int ret; ret = sys_test_bit(addr, bit); sys_clear_bit(addr, bit); return ret; } static inline __attribute__((always_inline)) int sys_bitfield_test_and_set_bit(mem_addr_t addr, unsigned int bit) { int ret; ret = sys_bitfield_test_bit(addr, bit); sys_bitfield_set_bit(addr, bit); return ret; } static inline __attribute__((always_inline)) int sys_bitfield_test_and_clear_bit(mem_addr_t addr, unsigned int bit) { int ret; ret = sys_bitfield_test_bit(addr, bit); sys_bitfield_clear_bit(addr, bit); return ret; } static inline __attribute__((always_inline)) unsigned int find_msb_set(uint32_t op) { if (op == 0) { return 0; } return 32 - __builtin_clz(op); } static inline __attribute__((always_inline)) unsigned int find_lsb_set(uint32_t op) { return __builtin_ffs(op); } struct arch_mem_domain { struct arm_mmu_ptables ptables; sys_snode_t node; }; typedef int64_t k_ticks_t; typedef struct { k_ticks_t ticks; } k_timeout_t; uint32_t sys_clock_tick_get_32(void); int64_t sys_clock_tick_get(void); typedef struct { uint64_t tick; } k_timepoint_t; k_timepoint_t sys_timepoint_calc(k_timeout_t timeout); k_timeout_t sys_timepoint_timeout(k_timepoint_t timepoint); __attribute__((deprecated)) static inline uint64_t sys_clock_timeout_end_calc(k_timeout_t timeout) { k_timepoint_t tp = sys_timepoint_calc(timeout); return tp.tick; } static inline int sys_timepoint_cmp(k_timepoint_t a, k_timepoint_t b) { if (a.tick == b.tick) { return 0; } return a.tick < b.tick ? -1 : 1; } static inline _Bool sys_timepoint_expired(k_timepoint_t timepoint) { return ((sys_timepoint_timeout(timepoint)).ticks == (((k_timeout_t) {0})).ticks); } extern int *__errno_location (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); struct z_spinlock_key { int key; }; struct k_spinlock { }; typedef struct z_spinlock_key k_spinlock_key_t; static inline __attribute__((always_inline)) void z_spinlock_validate_pre(struct k_spinlock *l) { (void)(l); } static inline __attribute__((always_inline)) void z_spinlock_validate_post(struct k_spinlock *l) { (void)(l); } static inline __attribute__((always_inline)) k_spinlock_key_t k_spin_lock(struct k_spinlock *l) { (void)(l); k_spinlock_key_t k; k.key = arch_irq_lock(); z_spinlock_validate_pre(l); z_spinlock_validate_post(l); return k; } static inline __attribute__((always_inline)) int k_spin_trylock(struct k_spinlock *l, k_spinlock_key_t *k) { int key = arch_irq_lock(); z_spinlock_validate_pre(l); z_spinlock_validate_post(l); k->key = key; return 0; } static inline __attribute__((always_inline)) void k_spin_unlock(struct k_spinlock *l, k_spinlock_key_t key) { (void)(l); arch_irq_unlock(key.key); } static inline __attribute__((always_inline)) void k_spin_release(struct k_spinlock *l) { (void)(l); } enum k_fatal_error_reason { K_ERR_CPU_EXCEPTION, K_ERR_SPURIOUS_IRQ, K_ERR_STACK_CHK_FAIL, K_ERR_KERNEL_OOPS, K_ERR_KERNEL_PANIC, K_ERR_ARCH_START = 16 }; __attribute__((__noreturn__)) void k_fatal_halt(unsigned int reason); void k_sys_fatal_error_handler(unsigned int reason, const z_arch_esf_t *esf); void z_fatal_error(unsigned int reason, const z_arch_esf_t *esf); struct __attribute__((__packed__)) z_thread_stack_element { char data; }; static inline char *z_stack_ptr_align(char *ptr) { return (char *)(((unsigned long)(ptr) / (unsigned long)(16)) * (unsigned long)(16)); } static inline char *Z_KERNEL_STACK_BUFFER(k_thread_stack_t *sym) { return (char *)sym + ((size_t)0); } struct k_thread; struct _pipe_desc { sys_dnode_t node; unsigned char *buffer; size_t bytes_to_xfer; struct k_thread *thread; }; struct _thread_base { union { sys_dnode_t qnode_dlist; struct rbnode qnode_rb; }; _wait_q_t *pended_on; uint8_t user_options; uint8_t thread_state; union { struct { int8_t prio; uint8_t sched_locked; }; uint16_t preempt; }; uint32_t order_key; void *swap_data; struct _timeout timeout; }; typedef struct _thread_base _thread_base_t; typedef struct k_thread_runtime_stats { } k_thread_runtime_stats_t; struct z_poller { _Bool is_polling; uint8_t mode; }; struct k_thread { struct _thread_base base; struct _callee_saved callee_saved; void *init_data; _wait_q_t join_queue; int swap_retval; void *switch_handle; struct k_heap *resource_pool; uintptr_t tls; struct _thread_arch arch; }; typedef struct k_thread _thread_t; typedef struct k_thread *k_tid_t; struct k_mem_domain; struct k_mem_partition; extern int k_mem_domain_init(struct k_mem_domain *domain, uint8_t num_parts, struct k_mem_partition *parts[]); extern int k_mem_domain_add_partition(struct k_mem_domain *domain, struct k_mem_partition *part); extern int k_mem_domain_remove_partition(struct k_mem_domain *domain, struct k_mem_partition *part); extern int k_mem_domain_add_thread(struct k_mem_domain *domain, k_tid_t thread); static inline void k_object_init(const void *obj) { (void)(obj); } static inline struct k_object *k_object_create_dynamic_aligned(size_t align, size_t size) { (void)(align); (void)(size); return ((void *)0); } static inline struct k_object *k_object_create_dynamic(size_t size) { (void)(size); return ((void *)0); } struct k_thread; struct k_mutex; struct z_futex_data; enum k_objects { K_OBJ_ANY, K_OBJ_MEM_SLAB, K_OBJ_MSGQ, K_OBJ_MUTEX, K_OBJ_PIPE, K_OBJ_QUEUE, K_OBJ_POLL_SIGNAL, K_OBJ_SEM, K_OBJ_STACK, K_OBJ_THREAD, K_OBJ_TIMER, K_OBJ_THREAD_STACK_ELEMENT, K_OBJ_NET_SOCKET, K_OBJ_NET_IF, K_OBJ_SYS_MUTEX, K_OBJ_FUTEX, K_OBJ_CONDVAR, K_OBJ_DRIVER_UART, K_OBJ_DRIVER_CRYPTO, K_OBJ_DRIVER_ADC, K_OBJ_DRIVER_AUXDISPLAY, K_OBJ_DRIVER_BBRAM, K_OBJ_DRIVER_CAN, K_OBJ_DRIVER_CHARGER, K_OBJ_DRIVER_COREDUMP, K_OBJ_DRIVER_COUNTER, K_OBJ_DRIVER_DAC, K_OBJ_DRIVER_DAI, K_OBJ_DRIVER_DMA, K_OBJ_DRIVER_EDAC, K_OBJ_DRIVER_EEPROM, K_OBJ_DRIVER_FUEL_GAUGE_EMUL, K_OBJ_DRIVER_EMUL_SENSOR_BACKEND_API, K_OBJ_DRIVER_ENTROPY, K_OBJ_DRIVER_ESPI, K_OBJ_DRIVER_ESPI_SAF, K_OBJ_DRIVER_FLASH, K_OBJ_DRIVER_FPGA, K_OBJ_DRIVER_FUEL_GAUGE, K_OBJ_DRIVER_GNSS, K_OBJ_DRIVER_GPIO, K_OBJ_DRIVER_HWSPINLOCK, K_OBJ_DRIVER_I2C, K_OBJ_DRIVER_I2S, K_OBJ_DRIVER_I3C, K_OBJ_DRIVER_IPM, K_OBJ_DRIVER_KSCAN, K_OBJ_DRIVER_LED, K_OBJ_DRIVER_MBOX, K_OBJ_DRIVER_MDIO, K_OBJ_DRIVER_MIPI_DSI, K_OBJ_DRIVER_PECI, K_OBJ_DRIVER_PS2, K_OBJ_DRIVER_PTP_CLOCK, K_OBJ_DRIVER_PWM, K_OBJ_DRIVER_REGULATOR_PARENT, K_OBJ_DRIVER_REGULATOR, K_OBJ_DRIVER_RESET, K_OBJ_DRIVER_RETAINED_MEM, K_OBJ_DRIVER_RTC, K_OBJ_DRIVER_SDHC, K_OBJ_DRIVER_SENSOR, K_OBJ_DRIVER_SMBUS, K_OBJ_DRIVER_SPI, K_OBJ_DRIVER_SYSCON, K_OBJ_DRIVER_W1, K_OBJ_DRIVER_WDT, K_OBJ_DRIVER_CAN_TRANSCEIVER, K_OBJ_DRIVER_UART_MUX, K_OBJ_DRIVER_ITS, K_OBJ_DRIVER_TGPIO, K_OBJ_DRIVER_PCIE_CTRL, K_OBJ_DRIVER_SVC, K_OBJ_DRIVER_BC12_EMUL, K_OBJ_DRIVER_BC12, K_OBJ_DRIVER_TCPC, K_OBJ_DRIVER_IVSHMEM, K_OBJ_DRIVER_EC_HOST_CMD_BACKEND_API, K_OBJ_DRIVER_ETHPHY, K_OBJ_LAST }; static inline void z_impl_k_object_access_grant(const void *object, struct k_thread *thread) { (void)(object); (void)(thread); } static inline void k_object_access_revoke(const void *object, struct k_thread *thread) { (void)(object); (void)(thread); } static inline void z_impl_k_object_release(const void *object) { (void)(object); } static inline void k_object_access_all_grant(const void *object) { (void)(object); } static inline _Bool k_object_is_valid(const void *obj, enum k_objects otype) { (void)(obj); (void)(otype); return 1; } static inline void *z_impl_k_object_alloc(enum k_objects otype) { (void)(otype); return ((void *)0); } static inline void *z_impl_k_object_alloc_size(enum k_objects otype, size_t size) { (void)(otype); (void)(size); return ((void *)0); } static inline void k_object_free(void *obj) { (void)(obj); } extern void z_impl_k_object_access_grant(const void * object, struct k_thread * thread); static inline void k_object_access_grant(const void * object, struct k_thread * thread) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_object_access_grant(object, thread); } extern void z_impl_k_object_release(const void * object); static inline void k_object_release(const void * object) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_object_release(object); } extern void * z_impl_k_object_alloc(enum k_objects otype); static inline void * k_object_alloc(enum k_objects otype) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_object_alloc(otype); } extern void * z_impl_k_object_alloc_size(enum k_objects otype, size_t size); static inline void * k_object_alloc_size(enum k_objects otype, size_t size) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_object_alloc_size(otype, size); } struct k_thread; void z_init_cpu(int id); void z_sched_ipi(void); void z_smp_start_cpu(int id); extern int (*__Static_assert_function (void)) [!!sizeof (struct { int __error_if_negative: (sizeof(int32_t) == sizeof(int)) ? 2 : -1; })]; extern int (*__Static_assert_function (void)) [!!sizeof (struct { int __error_if_negative: (sizeof(int64_t) == sizeof(long long)) ? 2 : -1; })]; extern int (*__Static_assert_function (void)) [!!sizeof (struct { int __error_if_negative: (sizeof(intptr_t) == sizeof(long)) ? 2 : -1; })]; struct k_thread; struct k_mutex; struct k_sem; struct k_msgq; struct k_mbox; struct k_pipe; struct k_queue; struct k_fifo; struct k_lifo; struct k_stack; struct k_mem_slab; struct k_timer; struct k_poll_event; struct k_poll_signal; struct k_mem_domain; struct k_mem_partition; struct k_futex; struct k_event; enum execution_context_types { K_ISR = 0, K_COOP_THREAD, K_PREEMPT_THREAD, }; struct k_work_poll; typedef int (*_poller_cb_t)(struct k_poll_event *event, uint32_t state); typedef void (*k_thread_user_cb_t)(const struct k_thread *thread, void *user_data); void k_thread_foreach(k_thread_user_cb_t user_cb, void *user_data); void k_thread_foreach_unlocked( k_thread_user_cb_t user_cb, void *user_data); static inline k_thread_stack_t *k_thread_stack_alloc(size_t size, int flags); static inline int k_thread_stack_free(k_thread_stack_t *stack); static inline k_tid_t k_thread_create(struct k_thread *new_thread, k_thread_stack_t *stack, size_t stack_size, k_thread_entry_t entry, void *p1, void *p2, void *p3, int prio, uint32_t options, k_timeout_t delay); __attribute__((__noreturn__)) void k_thread_user_mode_enter(k_thread_entry_t entry, void *p1, void *p2, void *p3); static inline void k_thread_heap_assign(struct k_thread *thread, struct k_heap *heap) { thread->resource_pool = heap; } static inline int k_thread_join(struct k_thread *thread, k_timeout_t timeout); static inline int32_t k_sleep(k_timeout_t timeout); static inline int32_t k_msleep(int32_t ms) { return k_sleep(((k_timeout_t) { .ticks = ((k_ticks_t)((1) ? ( ((10000) == (1000)) ? (uint64_t) ((((ms) > (0)) ? (ms) : (0))) : ((1000) > (10000) && (1000) % (10000) == 0U) ? (((uint64_t) ((((ms) > (0)) ? (ms) : (0))) + ((0) ? ((1000) / (10000)) / 2 : (1) ? ((1000) / (10000)) - 1 : 0)) / ((1000)/(10000) ? (1000)/(10000) : 01u)) : ((10000) > (1000) && (10000) % (1000) == 0U) ? (uint64_t) ((((ms) > (0)) ? (ms) : (0)))*((10000) / (1000)) : ((((((365 * 24ULL * 3600ULL * 1000) + ((4294967295U)) - 1) / ((4294967295U))) * 10000) <= (4294967295U)) ? (((uint64_t) ((((ms) > (0)) ? (ms) : (0)))*(10000) + ((0) ? (1000) / 2 : (1) ? (1000) - 1 : 0)) / (1000)) : (((uint64_t) ((((ms) > (0)) ? (ms) : (0))) / (1000))*(10000) + (((uint64_t) ((((ms) > (0)) ? (ms) : (0))) % (1000))*(10000) + ((0) ? (1000) / 2 : (1) ? (1000) - 1 : 0)) / (1000))) ) : (((uint64_t) ((((ms) > (0)) ? (ms) : (0))) / (1000))*(10000) + (((uint64_t) ((((ms) > (0)) ? (ms) : (0))) % (1000))*(10000) + ((0) ? (1000) / 2 : (1) ? (1000) - 1 : 0)) / (1000)) )) })); } static inline int32_t k_usleep(int32_t us); static inline void k_busy_wait(uint32_t usec_to_wait); _Bool k_can_yield(void); static inline void k_yield(void); static inline void k_wakeup(k_tid_t thread); __attribute__ ((__const__)) static inline k_tid_t k_sched_current_thread_query(void); __attribute__ ((__const__)) static inline k_tid_t k_current_get(void) { extern __thread k_tid_t z_tls_current; return z_tls_current; } static inline void k_thread_abort(k_tid_t thread); static inline void k_thread_start(k_tid_t thread); k_ticks_t z_timeout_expires(const struct _timeout *timeout); k_ticks_t z_timeout_remaining(const struct _timeout *timeout); static inline k_ticks_t k_thread_timeout_expires_ticks(const struct k_thread *t); static inline k_ticks_t z_impl_k_thread_timeout_expires_ticks( const struct k_thread *t) { return z_timeout_expires(&t->base.timeout); } static inline k_ticks_t k_thread_timeout_remaining_ticks(const struct k_thread *t); static inline k_ticks_t z_impl_k_thread_timeout_remaining_ticks( const struct k_thread *t) { return z_timeout_remaining(&t->base.timeout); } struct _static_thread_data { struct k_thread *init_thread; k_thread_stack_t *init_stack; unsigned int init_stack_size; k_thread_entry_t init_entry; void *init_p1; void *init_p2; void *init_p3; int init_prio; uint32_t init_options; const char *init_name; int32_t init_delay_ms; }; static inline int k_thread_priority_get(k_tid_t thread); static inline void k_thread_priority_set(k_tid_t thread, int prio); static inline void k_thread_suspend(k_tid_t thread); static inline void k_thread_resume(k_tid_t thread); void k_sched_time_slice_set(int32_t slice, int prio); void k_thread_time_slice_set(struct k_thread *th, int32_t slice_ticks, k_thread_timeslice_fn_t expired, void *data); _Bool k_is_in_isr(void); static inline int k_is_preempt_thread(void); static inline _Bool k_is_pre_kernel(void) { extern _Bool z_sys_post_kernel; return !z_sys_post_kernel; } void k_sched_lock(void); void k_sched_unlock(void); static inline void k_thread_custom_data_set(void *value); static inline void *k_thread_custom_data_get(void); static inline int k_thread_name_set(k_tid_t thread, const char *str); const char *k_thread_name_get(k_tid_t thread); static inline int k_thread_name_copy(k_tid_t thread, char *buf, size_t size); const char *k_thread_state_str(k_tid_t thread_id, char *buf, size_t buf_size); struct k_timer { struct _timeout timeout; _wait_q_t wait_q; void (*expiry_fn)(struct k_timer *timer); void (*stop_fn)(struct k_timer *timer); k_timeout_t period; uint32_t status; void *user_data; }; typedef void (*k_timer_expiry_t)(struct k_timer *timer); typedef void (*k_timer_stop_t)(struct k_timer *timer); void k_timer_init(struct k_timer *timer, k_timer_expiry_t expiry_fn, k_timer_stop_t stop_fn); static inline void k_timer_start(struct k_timer *timer, k_timeout_t duration, k_timeout_t period); static inline void k_timer_stop(struct k_timer *timer); static inline uint32_t k_timer_status_get(struct k_timer *timer); static inline uint32_t k_timer_status_sync(struct k_timer *timer); static inline k_ticks_t k_timer_expires_ticks(const struct k_timer *timer); static inline k_ticks_t z_impl_k_timer_expires_ticks( const struct k_timer *timer) { return z_timeout_expires(&timer->timeout); } static inline k_ticks_t k_timer_remaining_ticks(const struct k_timer *timer); static inline k_ticks_t z_impl_k_timer_remaining_ticks( const struct k_timer *timer) { return z_timeout_remaining(&timer->timeout); } static inline uint32_t k_timer_remaining_get(struct k_timer *timer) { return ((1) ? ( ((1000) == (10000)) ? (uint32_t) (k_timer_remaining_ticks(timer)) : ((10000) > (1000) && (10000) % (1000) == 0U) ? ((uint64_t) (k_timer_remaining_ticks(timer)) <= 0xffffffffU - ((0) ? ((10000) / (1000)) / 2 : (0) ? ((10000) / (1000)) - 1 : 0) ? ((uint32_t)((k_timer_remaining_ticks(timer)) + ((0) ? ((10000) / (1000)) / 2 : (0) ? ((10000) / (1000)) - 1 : 0)) / ((10000)/(1000) ? (10000)/(1000) : 01u)) : (uint32_t) (((uint64_t) (k_timer_remaining_ticks(timer)) + ((0) ? ((10000) / (1000)) / 2 : (0) ? ((10000) / (1000)) - 1 : 0)) / ((10000)/(1000) ? (10000)/(1000) : 01u)) ) : ((1000) > (10000) && (1000) % (10000) == 0U) ? (uint32_t) (k_timer_remaining_ticks(timer))*((1000) / (10000)) : ((uint32_t) (((uint64_t) (k_timer_remaining_ticks(timer))*(1000) + ((0) ? (10000) / 2 : (0) ? (10000) - 1 : 0)) / (10000))) ) : ((uint32_t) (((uint64_t) (k_timer_remaining_ticks(timer))*(1000) + ((0) ? (10000) / 2 : (0) ? (10000) - 1 : 0)) / (10000))) ); } static inline void k_timer_user_data_set(struct k_timer *timer, void *user_data); static inline void z_impl_k_timer_user_data_set(struct k_timer *timer, void *user_data) { timer->user_data = user_data; } static inline void *k_timer_user_data_get(const struct k_timer *timer); static inline void *z_impl_k_timer_user_data_get(const struct k_timer *timer) { return timer->user_data; } static inline int64_t k_uptime_ticks(void); static inline int64_t k_uptime_get(void) { return ((1) ? ( ((1000) == (10000)) ? (uint64_t) (k_uptime_ticks()) : ((10000) > (1000) && (10000) % (1000) == 0U) ? (((uint64_t) (k_uptime_ticks()) + ((0) ? ((10000) / (1000)) / 2 : (0) ? ((10000) / (1000)) - 1 : 0)) / ((10000)/(1000) ? (10000)/(1000) : 01u)) : ((1000) > (10000) && (1000) % (10000) == 0U) ? (uint64_t) (k_uptime_ticks())*((1000) / (10000)) : ((((((365 * 24ULL * 3600ULL * 10000) + ((4294967295U)) - 1) / ((4294967295U))) * 1000) <= (4294967295U)) ? (((uint64_t) (k_uptime_ticks())*(1000) + ((0) ? (10000) / 2 : (0) ? (10000) - 1 : 0)) / (10000)) : (((uint64_t) (k_uptime_ticks()) / (10000))*(1000) + (((uint64_t) (k_uptime_ticks()) % (10000))*(1000) + ((0) ? (10000) / 2 : (0) ? (10000) - 1 : 0)) / (10000))) ) : (((uint64_t) (k_uptime_ticks()) / (10000))*(1000) + (((uint64_t) (k_uptime_ticks()) % (10000))*(1000) + ((0) ? (10000) / 2 : (0) ? (10000) - 1 : 0)) / (10000)) ); } static inline uint32_t k_uptime_get_32(void) { return (uint32_t)k_uptime_get(); } static inline int64_t k_uptime_delta(int64_t *reftime) { int64_t uptime, delta; uptime = k_uptime_get(); delta = uptime - *reftime; *reftime = uptime; return delta; } static inline uint32_t k_cycle_get_32(void) { return arch_k_cycle_get_32(); } static inline uint64_t k_cycle_get_64(void) { if (!1) { { }; return 0; } return arch_k_cycle_get_64(); } struct k_queue { sys_sflist_t data_q; struct k_spinlock lock; _wait_q_t wait_q; }; static inline void k_queue_init(struct k_queue *queue); static inline void k_queue_cancel_wait(struct k_queue *queue); void k_queue_append(struct k_queue *queue, void *data); static inline int32_t k_queue_alloc_append(struct k_queue *queue, void *data); void k_queue_prepend(struct k_queue *queue, void *data); static inline int32_t k_queue_alloc_prepend(struct k_queue *queue, void *data); void k_queue_insert(struct k_queue *queue, void *prev, void *data); int k_queue_append_list(struct k_queue *queue, void *head, void *tail); int k_queue_merge_slist(struct k_queue *queue, sys_slist_t *list); static inline void *k_queue_get(struct k_queue *queue, k_timeout_t timeout); _Bool k_queue_remove(struct k_queue *queue, void *data); _Bool k_queue_unique_append(struct k_queue *queue, void *data); static inline int k_queue_is_empty(struct k_queue *queue); static inline int z_impl_k_queue_is_empty(struct k_queue *queue) { return (int)sys_sflist_is_empty(&queue->data_q); } static inline void *k_queue_peek_head(struct k_queue *queue); static inline void *k_queue_peek_tail(struct k_queue *queue); struct k_event { _wait_q_t wait_q; uint32_t events; struct k_spinlock lock; }; static inline void k_event_init(struct k_event *event); static inline uint32_t k_event_post(struct k_event *event, uint32_t events); static inline uint32_t k_event_set(struct k_event *event, uint32_t events); static inline uint32_t k_event_set_masked(struct k_event *event, uint32_t events, uint32_t events_mask); static inline uint32_t k_event_clear(struct k_event *event, uint32_t events); static inline uint32_t k_event_wait(struct k_event *event, uint32_t events, _Bool reset, k_timeout_t timeout); static inline uint32_t k_event_wait_all(struct k_event *event, uint32_t events, _Bool reset, k_timeout_t timeout); static inline uint32_t k_event_test(struct k_event *event, uint32_t events_mask) { return k_event_wait(event, events_mask, 0, ((k_timeout_t) {0})); } struct k_fifo { struct k_queue _queue; }; struct k_lifo { struct k_queue _queue; }; typedef uintptr_t stack_data_t; struct k_stack { _wait_q_t wait_q; struct k_spinlock lock; stack_data_t *base, *next, *top; uint8_t flags; }; void k_stack_init(struct k_stack *stack, stack_data_t *buffer, uint32_t num_entries); static inline int32_t k_stack_alloc_init(struct k_stack *stack, uint32_t num_entries); int k_stack_cleanup(struct k_stack *stack); static inline int k_stack_push(struct k_stack *stack, stack_data_t data); static inline int k_stack_pop(struct k_stack *stack, stack_data_t *data, k_timeout_t timeout); struct k_work; struct k_work_q; struct k_work_queue_config; extern struct k_work_q k_sys_work_q; struct k_mutex { _wait_q_t wait_q; struct k_thread *owner; uint32_t lock_count; int owner_orig_prio; }; static inline int k_mutex_init(struct k_mutex *mutex); static inline int k_mutex_lock(struct k_mutex *mutex, k_timeout_t timeout); static inline int k_mutex_unlock(struct k_mutex *mutex); struct k_condvar { _wait_q_t wait_q; }; static inline int k_condvar_init(struct k_condvar *condvar); static inline int k_condvar_signal(struct k_condvar *condvar); static inline int k_condvar_broadcast(struct k_condvar *condvar); static inline int k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex, k_timeout_t timeout); struct k_sem { _wait_q_t wait_q; unsigned int count; unsigned int limit; }; static inline int k_sem_init(struct k_sem *sem, unsigned int initial_count, unsigned int limit); static inline int k_sem_take(struct k_sem *sem, k_timeout_t timeout); static inline void k_sem_give(struct k_sem *sem); static inline void k_sem_reset(struct k_sem *sem); static inline unsigned int k_sem_count_get(struct k_sem *sem); static inline unsigned int z_impl_k_sem_count_get(struct k_sem *sem) { return sem->count; } struct k_work_delayable; struct k_work_sync; typedef void (*k_work_handler_t)(struct k_work *work); void k_work_init(struct k_work *work, k_work_handler_t handler); int k_work_busy_get(const struct k_work *work); static inline _Bool k_work_is_pending(const struct k_work *work); int k_work_submit_to_queue(struct k_work_q *queue, struct k_work *work); int k_work_submit(struct k_work *work); _Bool k_work_flush(struct k_work *work, struct k_work_sync *sync); int k_work_cancel(struct k_work *work); _Bool k_work_cancel_sync(struct k_work *work, struct k_work_sync *sync); void k_work_queue_init(struct k_work_q *queue); void k_work_queue_start(struct k_work_q *queue, k_thread_stack_t *stack, size_t stack_size, int prio, const struct k_work_queue_config *cfg); static inline k_tid_t k_work_queue_thread_get(struct k_work_q *queue); int k_work_queue_drain(struct k_work_q *queue, _Bool plug); int k_work_queue_unplug(struct k_work_q *queue); void k_work_init_delayable(struct k_work_delayable *dwork, k_work_handler_t handler); static inline struct k_work_delayable * k_work_delayable_from_work(struct k_work *work); int k_work_delayable_busy_get(const struct k_work_delayable *dwork); static inline _Bool k_work_delayable_is_pending( const struct k_work_delayable *dwork); static inline k_ticks_t k_work_delayable_expires_get( const struct k_work_delayable *dwork); static inline k_ticks_t k_work_delayable_remaining_get( const struct k_work_delayable *dwork); int k_work_schedule_for_queue(struct k_work_q *queue, struct k_work_delayable *dwork, k_timeout_t delay); int k_work_schedule(struct k_work_delayable *dwork, k_timeout_t delay); int k_work_reschedule_for_queue(struct k_work_q *queue, struct k_work_delayable *dwork, k_timeout_t delay); int k_work_reschedule(struct k_work_delayable *dwork, k_timeout_t delay); _Bool k_work_flush_delayable(struct k_work_delayable *dwork, struct k_work_sync *sync); int k_work_cancel_delayable(struct k_work_delayable *dwork); _Bool k_work_cancel_delayable_sync(struct k_work_delayable *dwork, struct k_work_sync *sync); enum { K_WORK_RUNNING_BIT = 0, K_WORK_CANCELING_BIT = 1, K_WORK_QUEUED_BIT = 2, K_WORK_DELAYED_BIT = 3, K_WORK_MASK = (1UL << (K_WORK_DELAYED_BIT)) | (1UL << (K_WORK_QUEUED_BIT)) | (1UL << (K_WORK_RUNNING_BIT)) | (1UL << (K_WORK_CANCELING_BIT)), K_WORK_DELAYABLE_BIT = 8, K_WORK_DELAYABLE = (1UL << (K_WORK_DELAYABLE_BIT)), K_WORK_QUEUE_STARTED_BIT = 0, K_WORK_QUEUE_STARTED = (1UL << (K_WORK_QUEUE_STARTED_BIT)), K_WORK_QUEUE_BUSY_BIT = 1, K_WORK_QUEUE_BUSY = (1UL << (K_WORK_QUEUE_BUSY_BIT)), K_WORK_QUEUE_DRAIN_BIT = 2, K_WORK_QUEUE_DRAIN = (1UL << (K_WORK_QUEUE_DRAIN_BIT)), K_WORK_QUEUE_PLUGGED_BIT = 3, K_WORK_QUEUE_PLUGGED = (1UL << (K_WORK_QUEUE_PLUGGED_BIT)), K_WORK_QUEUE_NO_YIELD_BIT = 8, K_WORK_QUEUE_NO_YIELD = (1UL << (K_WORK_QUEUE_NO_YIELD_BIT)), K_WORK_RUNNING = (1UL << (K_WORK_RUNNING_BIT)), K_WORK_CANCELING = (1UL << (K_WORK_CANCELING_BIT)), K_WORK_QUEUED = (1UL << (K_WORK_QUEUED_BIT)), K_WORK_DELAYED = (1UL << (K_WORK_DELAYED_BIT)), }; struct k_work { sys_snode_t node; k_work_handler_t handler; struct k_work_q *queue; uint32_t flags; }; struct k_work_delayable { struct k_work work; struct _timeout timeout; struct k_work_q *queue; }; struct z_work_flusher { struct k_work work; struct k_sem sem; }; struct z_work_canceller { sys_snode_t node; struct k_work *work; struct k_sem sem; }; struct k_work_sync { union { struct z_work_flusher flusher; struct z_work_canceller canceller; }; }; struct k_work_queue_config { const char *name; _Bool no_yield; }; struct k_work_q { struct k_thread thread; sys_slist_t pending; _wait_q_t notifyq; _wait_q_t drainq; uint32_t flags; }; static inline _Bool k_work_is_pending(const struct k_work *work) { return k_work_busy_get(work) != 0; } static inline struct k_work_delayable * k_work_delayable_from_work(struct k_work *work) { return ({ extern int (*__Static_assert_function (void)) [!!sizeof (struct { int __error_if_negative: (__builtin_types_compatible_p(__typeof__(*(work)), __typeof__(((struct k_work_delayable *)0)->work)) || __builtin_types_compatible_p(__typeof__(*(work)), __typeof__(void))) ? 2 : -1; })]; ((struct k_work_delayable *)(((char *)(work)) - __builtin_offsetof (struct k_work_delayable, work))); }); } static inline _Bool k_work_delayable_is_pending( const struct k_work_delayable *dwork) { return k_work_delayable_busy_get(dwork) != 0; } static inline k_ticks_t k_work_delayable_expires_get( const struct k_work_delayable *dwork) { return z_timeout_expires(&dwork->timeout); } static inline k_ticks_t k_work_delayable_remaining_get( const struct k_work_delayable *dwork) { return z_timeout_remaining(&dwork->timeout); } static inline k_tid_t k_work_queue_thread_get(struct k_work_q *queue) { return &queue->thread; } struct k_work_user; typedef void (*k_work_user_handler_t)(struct k_work_user *work); struct k_work_user_q { struct k_queue queue; struct k_thread thread; }; enum { K_WORK_USER_STATE_PENDING, }; struct k_work_user { void *_reserved; k_work_user_handler_t handler; atomic_t flags; }; static inline void k_work_user_init(struct k_work_user *work, k_work_user_handler_t handler) { *work = (struct k_work_user){ ._reserved = ((void *)0), .handler = handler, .flags = 0 }; } static inline _Bool k_work_user_is_pending(struct k_work_user *work) { return atomic_test_bit(&work->flags, K_WORK_USER_STATE_PENDING); } static inline int k_work_user_submit_to_queue(struct k_work_user_q *work_q, struct k_work_user *work) { int ret = -16; if (!atomic_test_and_set_bit(&work->flags, K_WORK_USER_STATE_PENDING)) { ret = k_queue_alloc_append(&work_q->queue, work); if (ret != 0) { atomic_clear_bit(&work->flags, K_WORK_USER_STATE_PENDING); } } return ret; } void k_work_user_queue_start(struct k_work_user_q *work_q, k_thread_stack_t *stack, size_t stack_size, int prio, const char *name); static inline k_tid_t k_work_user_queue_thread_get(struct k_work_user_q *work_q) { return &work_q->thread; } struct k_work_poll { struct k_work work; struct k_work_q *workq; struct z_poller poller; struct k_poll_event *events; int num_events; k_work_handler_t real_handler; struct _timeout timeout; int poll_result; }; void k_work_poll_init(struct k_work_poll *work, k_work_handler_t handler); int k_work_poll_submit_to_queue(struct k_work_q *work_q, struct k_work_poll *work, struct k_poll_event *events, int num_events, k_timeout_t timeout); int k_work_poll_submit(struct k_work_poll *work, struct k_poll_event *events, int num_events, k_timeout_t timeout); int k_work_poll_cancel(struct k_work_poll *work); struct k_msgq { _wait_q_t wait_q; struct k_spinlock lock; size_t msg_size; uint32_t max_msgs; char *buffer_start; char *buffer_end; char *read_ptr; char *write_ptr; uint32_t used_msgs; uint8_t flags; }; struct k_msgq_attrs { size_t msg_size; uint32_t max_msgs; uint32_t used_msgs; }; void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size, uint32_t max_msgs); static inline int k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size, uint32_t max_msgs); int k_msgq_cleanup(struct k_msgq *msgq); static inline int k_msgq_put(struct k_msgq *msgq, const void *data, k_timeout_t timeout); static inline int k_msgq_get(struct k_msgq *msgq, void *data, k_timeout_t timeout); static inline int k_msgq_peek(struct k_msgq *msgq, void *data); static inline int k_msgq_peek_at(struct k_msgq *msgq, void *data, uint32_t idx); static inline void k_msgq_purge(struct k_msgq *msgq); static inline uint32_t k_msgq_num_free_get(struct k_msgq *msgq); static inline void k_msgq_get_attrs(struct k_msgq *msgq, struct k_msgq_attrs *attrs); static inline uint32_t z_impl_k_msgq_num_free_get(struct k_msgq *msgq) { return msgq->max_msgs - msgq->used_msgs; } static inline uint32_t k_msgq_num_used_get(struct k_msgq *msgq); static inline uint32_t z_impl_k_msgq_num_used_get(struct k_msgq *msgq) { return msgq->used_msgs; } struct k_mbox_msg { size_t size; uint32_t info; void *tx_data; k_tid_t rx_source_thread; k_tid_t tx_target_thread; k_tid_t _syncing_thread; struct k_sem *_async_sem; }; struct k_mbox { _wait_q_t tx_msg_queue; _wait_q_t rx_msg_queue; struct k_spinlock lock; }; void k_mbox_init(struct k_mbox *mbox); int k_mbox_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg, k_timeout_t timeout); void k_mbox_async_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg, struct k_sem *sem); int k_mbox_get(struct k_mbox *mbox, struct k_mbox_msg *rx_msg, void *buffer, k_timeout_t timeout); void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer); struct k_pipe { unsigned char *buffer; size_t size; size_t bytes_used; size_t read_index; size_t write_index; struct k_spinlock lock; struct { _wait_q_t readers; _wait_q_t writers; } wait_q; uint8_t flags; }; void k_pipe_init(struct k_pipe *pipe, unsigned char *buffer, size_t size); int k_pipe_cleanup(struct k_pipe *pipe); static inline int k_pipe_alloc_init(struct k_pipe *pipe, size_t size); static inline int k_pipe_put(struct k_pipe *pipe, const void *data, size_t bytes_to_write, size_t *bytes_written, size_t min_xfer, k_timeout_t timeout); static inline int k_pipe_get(struct k_pipe *pipe, void *data, size_t bytes_to_read, size_t *bytes_read, size_t min_xfer, k_timeout_t timeout); static inline size_t k_pipe_read_avail(struct k_pipe *pipe); static inline size_t k_pipe_write_avail(struct k_pipe *pipe); static inline void k_pipe_flush(struct k_pipe *pipe); static inline void k_pipe_buffer_flush(struct k_pipe *pipe); struct k_mem_slab_info { uint32_t num_blocks; size_t block_size; uint32_t num_used; }; struct k_mem_slab { _wait_q_t wait_q; struct k_spinlock lock; char *buffer; char *free_list; struct k_mem_slab_info info; }; int k_mem_slab_init(struct k_mem_slab *slab, void *buffer, size_t block_size, uint32_t num_blocks); int k_mem_slab_alloc(struct k_mem_slab *slab, void **mem, k_timeout_t timeout); void k_mem_slab_free(struct k_mem_slab *slab, void *mem); static inline uint32_t k_mem_slab_num_used_get(struct k_mem_slab *slab) { return slab->info.num_used; } static inline uint32_t k_mem_slab_max_used_get(struct k_mem_slab *slab) { (void)(slab); return 0; } static inline uint32_t k_mem_slab_num_free_get(struct k_mem_slab *slab) { return slab->info.num_blocks - slab->info.num_used; } int k_mem_slab_runtime_stats_get(struct k_mem_slab *slab, struct sys_memory_stats *stats); int k_mem_slab_runtime_stats_reset_max(struct k_mem_slab *slab); struct k_heap { struct sys_heap heap; _wait_q_t wait_q; struct k_spinlock lock; }; void k_heap_init(struct k_heap *h, void *mem, size_t bytes) __attribute__((nonnull(1))); void *k_heap_aligned_alloc(struct k_heap *h, size_t align, size_t bytes, k_timeout_t timeout) __attribute__((nonnull(1))); void *k_heap_alloc(struct k_heap *h, size_t bytes, k_timeout_t timeout) __attribute__((nonnull(1))); void k_heap_free(struct k_heap *h, void *mem) __attribute__((nonnull(1))); void *k_aligned_alloc(size_t align, size_t size); void *k_malloc(size_t size); void k_free(void *ptr); void *k_calloc(size_t nmemb, size_t size); enum _poll_types_bits { _POLL_TYPE_IGNORE, _POLL_TYPE_SIGNAL, _POLL_TYPE_SEM_AVAILABLE, _POLL_TYPE_DATA_AVAILABLE, _POLL_TYPE_MSGQ_DATA_AVAILABLE, _POLL_TYPE_PIPE_DATA_AVAILABLE, _POLL_NUM_TYPES }; enum _poll_states_bits { _POLL_STATE_NOT_READY, _POLL_STATE_SIGNALED, _POLL_STATE_SEM_AVAILABLE, _POLL_STATE_DATA_AVAILABLE, _POLL_STATE_CANCELLED, _POLL_STATE_MSGQ_DATA_AVAILABLE, _POLL_STATE_PIPE_DATA_AVAILABLE, _POLL_NUM_STATES }; enum k_poll_modes { K_POLL_MODE_NOTIFY_ONLY = 0, K_POLL_NUM_MODES }; struct k_poll_signal { sys_dlist_t poll_events; unsigned int signaled; int result; }; struct k_poll_event { sys_dnode_t _node; struct z_poller *poller; uint32_t tag:8; uint32_t type:_POLL_NUM_TYPES; uint32_t state:_POLL_NUM_STATES; uint32_t mode:1; uint32_t unused:(32 - (0 + 8 + _POLL_NUM_TYPES + _POLL_NUM_STATES + 1 )); union { void *obj; struct k_poll_signal *signal; struct k_sem *sem; struct k_fifo *fifo; struct k_queue *queue; struct k_msgq *msgq; }; }; void k_poll_event_init(struct k_poll_event *event, uint32_t type, int mode, void *obj); static inline int k_poll(struct k_poll_event *events, int num_events, k_timeout_t timeout); static inline void k_poll_signal_init(struct k_poll_signal *sig); static inline void k_poll_signal_reset(struct k_poll_signal *sig); static inline void k_poll_signal_check(struct k_poll_signal *sig, unsigned int *signaled, int *result); static inline int k_poll_signal_raise(struct k_poll_signal *sig, int result); static inline void k_cpu_idle(void) { arch_cpu_idle(); } static inline void k_cpu_atomic_idle(unsigned int key) { arch_cpu_atomic_idle(key); } void z_init_static_threads(void); void z_timer_expiration_handler(struct _timeout *t); static inline void k_str_out(char *c, size_t n); static inline int k_float_disable(struct k_thread *thread); static inline int k_float_enable(struct k_thread *thread, unsigned int options); int k_thread_runtime_stats_get(k_tid_t thread, k_thread_runtime_stats_t *stats); int k_thread_runtime_stats_all_get(k_thread_runtime_stats_t *stats); int k_thread_runtime_stats_enable(k_tid_t thread); int k_thread_runtime_stats_disable(k_tid_t thread); void k_sys_runtime_stats_enable(void); void k_sys_runtime_stats_disable(void); void sys_trace_isr_enter(void); void sys_trace_isr_exit(void); void sys_trace_isr_exit_to_scheduler(void); void sys_trace_idle(void); extern k_thread_stack_t * z_impl_k_thread_stack_alloc(size_t size, int flags); static inline k_thread_stack_t * k_thread_stack_alloc(size_t size, int flags) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_thread_stack_alloc(size, flags); } extern int z_impl_k_thread_stack_free(k_thread_stack_t * stack); static inline int k_thread_stack_free(k_thread_stack_t * stack) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_thread_stack_free(stack); } extern k_tid_t z_impl_k_thread_create(struct k_thread * new_thread, k_thread_stack_t * stack, size_t stack_size, k_thread_entry_t entry, void * p1, void * p2, void * p3, int prio, uint32_t options, k_timeout_t delay); static inline k_tid_t k_thread_create(struct k_thread * new_thread, k_thread_stack_t * stack, size_t stack_size, k_thread_entry_t entry, void * p1, void * p2, void * p3, int prio, uint32_t options, k_timeout_t delay) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_thread_create(new_thread, stack, stack_size, entry, p1, p2, p3, prio, options, delay); } extern int z_impl_k_thread_stack_space_get(const struct k_thread * thread, size_t * unused_ptr); static inline int k_thread_stack_space_get(const struct k_thread * thread, size_t * unused_ptr) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_thread_stack_space_get(thread, unused_ptr); } extern int z_impl_k_thread_join(struct k_thread * thread, k_timeout_t timeout); static inline int k_thread_join(struct k_thread * thread, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_thread_join(thread, timeout); } extern int32_t z_impl_k_sleep(k_timeout_t timeout); static inline int32_t k_sleep(k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_sleep(timeout); } extern int32_t z_impl_k_usleep(int32_t us); static inline int32_t k_usleep(int32_t us) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_usleep(us); } extern void z_impl_k_busy_wait(uint32_t usec_to_wait); static inline void k_busy_wait(uint32_t usec_to_wait) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_busy_wait(usec_to_wait); } extern void z_impl_k_yield(void); static inline void k_yield(void) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_yield(); } extern void z_impl_k_wakeup(k_tid_t thread); static inline void k_wakeup(k_tid_t thread) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_wakeup(thread); } extern k_tid_t z_impl_k_sched_current_thread_query(void); static inline k_tid_t k_sched_current_thread_query(void) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_sched_current_thread_query(); } extern void z_impl_k_thread_abort(k_tid_t thread); static inline void k_thread_abort(k_tid_t thread) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_thread_abort(thread); } extern void z_impl_k_thread_start(k_tid_t thread); static inline void k_thread_start(k_tid_t thread) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_thread_start(thread); } extern k_ticks_t z_impl_k_thread_timeout_expires_ticks(const struct k_thread * t); static inline k_ticks_t k_thread_timeout_expires_ticks(const struct k_thread * t) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_thread_timeout_expires_ticks(t); } extern k_ticks_t z_impl_k_thread_timeout_remaining_ticks(const struct k_thread * t); static inline k_ticks_t k_thread_timeout_remaining_ticks(const struct k_thread * t) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_thread_timeout_remaining_ticks(t); } extern int z_impl_k_thread_priority_get(k_tid_t thread); static inline int k_thread_priority_get(k_tid_t thread) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_thread_priority_get(thread); } extern void z_impl_k_thread_priority_set(k_tid_t thread, int prio); static inline void k_thread_priority_set(k_tid_t thread, int prio) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_thread_priority_set(thread, prio); } extern void z_impl_k_thread_deadline_set(k_tid_t thread, int deadline); static inline void k_thread_deadline_set(k_tid_t thread, int deadline) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_thread_deadline_set(thread, deadline); } extern void z_impl_k_thread_suspend(k_tid_t thread); static inline void k_thread_suspend(k_tid_t thread) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_thread_suspend(thread); } extern void z_impl_k_thread_resume(k_tid_t thread); static inline void k_thread_resume(k_tid_t thread) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_thread_resume(thread); } extern int z_impl_k_is_preempt_thread(void); static inline int k_is_preempt_thread(void) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_is_preempt_thread(); } extern void z_impl_k_thread_custom_data_set(void * value); static inline void k_thread_custom_data_set(void * value) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_thread_custom_data_set(value); } extern void * z_impl_k_thread_custom_data_get(void); static inline void * k_thread_custom_data_get(void) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_thread_custom_data_get(); } extern int z_impl_k_thread_name_set(k_tid_t thread, const char * str); static inline int k_thread_name_set(k_tid_t thread, const char * str) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_thread_name_set(thread, str); } extern int z_impl_k_thread_name_copy(k_tid_t thread, char * buf, size_t size); static inline int k_thread_name_copy(k_tid_t thread, char * buf, size_t size) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_thread_name_copy(thread, buf, size); } extern void z_impl_k_timer_start(struct k_timer * timer, k_timeout_t duration, k_timeout_t period); static inline void k_timer_start(struct k_timer * timer, k_timeout_t duration, k_timeout_t period) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_timer_start(timer, duration, period); } extern void z_impl_k_timer_stop(struct k_timer * timer); static inline void k_timer_stop(struct k_timer * timer) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_timer_stop(timer); } extern uint32_t z_impl_k_timer_status_get(struct k_timer * timer); static inline uint32_t k_timer_status_get(struct k_timer * timer) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_timer_status_get(timer); } extern uint32_t z_impl_k_timer_status_sync(struct k_timer * timer); static inline uint32_t k_timer_status_sync(struct k_timer * timer) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_timer_status_sync(timer); } extern k_ticks_t z_impl_k_timer_expires_ticks(const struct k_timer * timer); static inline k_ticks_t k_timer_expires_ticks(const struct k_timer * timer) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_timer_expires_ticks(timer); } extern k_ticks_t z_impl_k_timer_remaining_ticks(const struct k_timer * timer); static inline k_ticks_t k_timer_remaining_ticks(const struct k_timer * timer) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_timer_remaining_ticks(timer); } extern void z_impl_k_timer_user_data_set(struct k_timer * timer, void * user_data); static inline void k_timer_user_data_set(struct k_timer * timer, void * user_data) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_timer_user_data_set(timer, user_data); } extern void * z_impl_k_timer_user_data_get(const struct k_timer * timer); static inline void * k_timer_user_data_get(const struct k_timer * timer) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_timer_user_data_get(timer); } extern int64_t z_impl_k_uptime_ticks(void); static inline int64_t k_uptime_ticks(void) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_uptime_ticks(); } extern void z_impl_k_queue_init(struct k_queue * queue); static inline void k_queue_init(struct k_queue * queue) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_queue_init(queue); } extern void z_impl_k_queue_cancel_wait(struct k_queue * queue); static inline void k_queue_cancel_wait(struct k_queue * queue) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_queue_cancel_wait(queue); } extern int32_t z_impl_k_queue_alloc_append(struct k_queue * queue, void * data); static inline int32_t k_queue_alloc_append(struct k_queue * queue, void * data) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_queue_alloc_append(queue, data); } extern int32_t z_impl_k_queue_alloc_prepend(struct k_queue * queue, void * data); static inline int32_t k_queue_alloc_prepend(struct k_queue * queue, void * data) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_queue_alloc_prepend(queue, data); } extern void * z_impl_k_queue_get(struct k_queue * queue, k_timeout_t timeout); static inline void * k_queue_get(struct k_queue * queue, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_queue_get(queue, timeout); } extern int z_impl_k_queue_is_empty(struct k_queue * queue); static inline int k_queue_is_empty(struct k_queue * queue) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_queue_is_empty(queue); } extern void * z_impl_k_queue_peek_head(struct k_queue * queue); static inline void * k_queue_peek_head(struct k_queue * queue) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_queue_peek_head(queue); } extern void * z_impl_k_queue_peek_tail(struct k_queue * queue); static inline void * k_queue_peek_tail(struct k_queue * queue) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_queue_peek_tail(queue); } extern int z_impl_k_futex_wait(struct k_futex * futex, int expected, k_timeout_t timeout); static inline int k_futex_wait(struct k_futex * futex, int expected, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_futex_wait(futex, expected, timeout); } extern int z_impl_k_futex_wake(struct k_futex * futex, _Bool wake_all); static inline int k_futex_wake(struct k_futex * futex, _Bool wake_all) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_futex_wake(futex, wake_all); } extern void z_impl_k_event_init(struct k_event * event); static inline void k_event_init(struct k_event * event) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_event_init(event); } extern uint32_t z_impl_k_event_post(struct k_event * event, uint32_t events); static inline uint32_t k_event_post(struct k_event * event, uint32_t events) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_event_post(event, events); } extern uint32_t z_impl_k_event_set(struct k_event * event, uint32_t events); static inline uint32_t k_event_set(struct k_event * event, uint32_t events) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_event_set(event, events); } extern uint32_t z_impl_k_event_set_masked(struct k_event * event, uint32_t events, uint32_t events_mask); static inline uint32_t k_event_set_masked(struct k_event * event, uint32_t events, uint32_t events_mask) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_event_set_masked(event, events, events_mask); } extern uint32_t z_impl_k_event_clear(struct k_event * event, uint32_t events); static inline uint32_t k_event_clear(struct k_event * event, uint32_t events) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_event_clear(event, events); } extern uint32_t z_impl_k_event_wait(struct k_event * event, uint32_t events, _Bool reset, k_timeout_t timeout); static inline uint32_t k_event_wait(struct k_event * event, uint32_t events, _Bool reset, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_event_wait(event, events, reset, timeout); } extern uint32_t z_impl_k_event_wait_all(struct k_event * event, uint32_t events, _Bool reset, k_timeout_t timeout); static inline uint32_t k_event_wait_all(struct k_event * event, uint32_t events, _Bool reset, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_event_wait_all(event, events, reset, timeout); } extern int32_t z_impl_k_stack_alloc_init(struct k_stack * stack, uint32_t num_entries); static inline int32_t k_stack_alloc_init(struct k_stack * stack, uint32_t num_entries) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_stack_alloc_init(stack, num_entries); } extern int z_impl_k_stack_push(struct k_stack * stack, stack_data_t data); static inline int k_stack_push(struct k_stack * stack, stack_data_t data) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_stack_push(stack, data); } extern int z_impl_k_stack_pop(struct k_stack * stack, stack_data_t * data, k_timeout_t timeout); static inline int k_stack_pop(struct k_stack * stack, stack_data_t * data, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_stack_pop(stack, data, timeout); } extern int z_impl_k_mutex_init(struct k_mutex * mutex); static inline int k_mutex_init(struct k_mutex * mutex) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_mutex_init(mutex); } extern int z_impl_k_mutex_lock(struct k_mutex * mutex, k_timeout_t timeout); static inline int k_mutex_lock(struct k_mutex * mutex, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_mutex_lock(mutex, timeout); } extern int z_impl_k_mutex_unlock(struct k_mutex * mutex); static inline int k_mutex_unlock(struct k_mutex * mutex) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_mutex_unlock(mutex); } extern int z_impl_k_condvar_init(struct k_condvar * condvar); static inline int k_condvar_init(struct k_condvar * condvar) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_condvar_init(condvar); } extern int z_impl_k_condvar_signal(struct k_condvar * condvar); static inline int k_condvar_signal(struct k_condvar * condvar) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_condvar_signal(condvar); } extern int z_impl_k_condvar_broadcast(struct k_condvar * condvar); static inline int k_condvar_broadcast(struct k_condvar * condvar) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_condvar_broadcast(condvar); } extern int z_impl_k_condvar_wait(struct k_condvar * condvar, struct k_mutex * mutex, k_timeout_t timeout); static inline int k_condvar_wait(struct k_condvar * condvar, struct k_mutex * mutex, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_condvar_wait(condvar, mutex, timeout); } extern int z_impl_k_sem_init(struct k_sem * sem, unsigned int initial_count, unsigned int limit); static inline int k_sem_init(struct k_sem * sem, unsigned int initial_count, unsigned int limit) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_sem_init(sem, initial_count, limit); } extern int z_impl_k_sem_take(struct k_sem * sem, k_timeout_t timeout); static inline int k_sem_take(struct k_sem * sem, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_sem_take(sem, timeout); } extern void z_impl_k_sem_give(struct k_sem * sem); static inline void k_sem_give(struct k_sem * sem) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_sem_give(sem); } extern void z_impl_k_sem_reset(struct k_sem * sem); static inline void k_sem_reset(struct k_sem * sem) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_sem_reset(sem); } extern unsigned int z_impl_k_sem_count_get(struct k_sem * sem); static inline unsigned int k_sem_count_get(struct k_sem * sem) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_sem_count_get(sem); } extern int z_impl_k_msgq_alloc_init(struct k_msgq * msgq, size_t msg_size, uint32_t max_msgs); static inline int k_msgq_alloc_init(struct k_msgq * msgq, size_t msg_size, uint32_t max_msgs) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_msgq_alloc_init(msgq, msg_size, max_msgs); } extern int z_impl_k_msgq_put(struct k_msgq * msgq, const void * data, k_timeout_t timeout); static inline int k_msgq_put(struct k_msgq * msgq, const void * data, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_msgq_put(msgq, data, timeout); } extern int z_impl_k_msgq_get(struct k_msgq * msgq, void * data, k_timeout_t timeout); static inline int k_msgq_get(struct k_msgq * msgq, void * data, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_msgq_get(msgq, data, timeout); } extern int z_impl_k_msgq_peek(struct k_msgq * msgq, void * data); static inline int k_msgq_peek(struct k_msgq * msgq, void * data) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_msgq_peek(msgq, data); } extern int z_impl_k_msgq_peek_at(struct k_msgq * msgq, void * data, uint32_t idx); static inline int k_msgq_peek_at(struct k_msgq * msgq, void * data, uint32_t idx) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_msgq_peek_at(msgq, data, idx); } extern void z_impl_k_msgq_purge(struct k_msgq * msgq); static inline void k_msgq_purge(struct k_msgq * msgq) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_msgq_purge(msgq); } extern uint32_t z_impl_k_msgq_num_free_get(struct k_msgq * msgq); static inline uint32_t k_msgq_num_free_get(struct k_msgq * msgq) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_msgq_num_free_get(msgq); } extern void z_impl_k_msgq_get_attrs(struct k_msgq * msgq, struct k_msgq_attrs * attrs); static inline void k_msgq_get_attrs(struct k_msgq * msgq, struct k_msgq_attrs * attrs) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_msgq_get_attrs(msgq, attrs); } extern uint32_t z_impl_k_msgq_num_used_get(struct k_msgq * msgq); static inline uint32_t k_msgq_num_used_get(struct k_msgq * msgq) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_msgq_num_used_get(msgq); } extern int z_impl_k_pipe_alloc_init(struct k_pipe * pipe, size_t size); static inline int k_pipe_alloc_init(struct k_pipe * pipe, size_t size) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_pipe_alloc_init(pipe, size); } extern int z_impl_k_pipe_put(struct k_pipe * pipe, const void * data, size_t bytes_to_write, size_t * bytes_written, size_t min_xfer, k_timeout_t timeout); static inline int k_pipe_put(struct k_pipe * pipe, const void * data, size_t bytes_to_write, size_t * bytes_written, size_t min_xfer, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_pipe_put(pipe, data, bytes_to_write, bytes_written, min_xfer, timeout); } extern int z_impl_k_pipe_get(struct k_pipe * pipe, void * data, size_t bytes_to_read, size_t * bytes_read, size_t min_xfer, k_timeout_t timeout); static inline int k_pipe_get(struct k_pipe * pipe, void * data, size_t bytes_to_read, size_t * bytes_read, size_t min_xfer, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_pipe_get(pipe, data, bytes_to_read, bytes_read, min_xfer, timeout); } extern size_t z_impl_k_pipe_read_avail(struct k_pipe * pipe); static inline size_t k_pipe_read_avail(struct k_pipe * pipe) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_pipe_read_avail(pipe); } extern size_t z_impl_k_pipe_write_avail(struct k_pipe * pipe); static inline size_t k_pipe_write_avail(struct k_pipe * pipe) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_pipe_write_avail(pipe); } extern void z_impl_k_pipe_flush(struct k_pipe * pipe); static inline void k_pipe_flush(struct k_pipe * pipe) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_pipe_flush(pipe); } extern void z_impl_k_pipe_buffer_flush(struct k_pipe * pipe); static inline void k_pipe_buffer_flush(struct k_pipe * pipe) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_pipe_buffer_flush(pipe); } extern int z_impl_k_poll(struct k_poll_event * events, int num_events, k_timeout_t timeout); static inline int k_poll(struct k_poll_event * events, int num_events, k_timeout_t timeout) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_poll(events, num_events, timeout); } extern void z_impl_k_poll_signal_init(struct k_poll_signal * sig); static inline void k_poll_signal_init(struct k_poll_signal * sig) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_poll_signal_init(sig); } extern void z_impl_k_poll_signal_reset(struct k_poll_signal * sig); static inline void k_poll_signal_reset(struct k_poll_signal * sig) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_poll_signal_reset(sig); } extern void z_impl_k_poll_signal_check(struct k_poll_signal * sig, unsigned int * signaled, int * result); static inline void k_poll_signal_check(struct k_poll_signal * sig, unsigned int * signaled, int * result) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_poll_signal_check(sig, signaled, result); } extern int z_impl_k_poll_signal_raise(struct k_poll_signal * sig, int result); static inline int k_poll_signal_raise(struct k_poll_signal * sig, int result) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_poll_signal_raise(sig, result); } extern void z_impl_k_str_out(char * c, size_t n); static inline void k_str_out(char * c, size_t n) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); z_impl_k_str_out(c, n); } extern int z_impl_k_float_disable(struct k_thread * thread); static inline int k_float_disable(struct k_thread * thread) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_float_disable(thread); } extern int z_impl_k_float_enable(struct k_thread * thread, unsigned int options); static inline int k_float_enable(struct k_thread * thread, unsigned int options) { do { __asm__ __volatile__ ("" ::: "memory"); } while (0); return z_impl_k_float_enable(thread, options); } void arch_busy_wait(uint32_t usec_to_wait); void arch_new_thread(struct k_thread *thread, k_thread_stack_t *stack, char *stack_ptr, k_thread_entry_t entry, void *p1, void *p2, void *p3); static inline void arch_switch(void *switch_to, void **switched_from); int arch_float_disable(struct k_thread *thread); int arch_float_enable(struct k_thread *thread, unsigned int options); __attribute__((__noreturn__)) void arch_system_halt(unsigned int reason); static inline _Bool arch_is_in_isr(void); void arch_mem_map(void *virt, uintptr_t phys, size_t size, uint32_t flags); void arch_mem_unmap(void *addr, size_t size); int arch_page_phys_get(void *virt, uintptr_t *phys); void arch_reserved_pages_update(void); void arch_mem_page_out(void *addr, uintptr_t location); void arch_mem_page_in(void *addr, uintptr_t phys); void arch_mem_scratch(uintptr_t phys); enum arch_page_location { ARCH_PAGE_LOCATION_PAGED_OUT, ARCH_PAGE_LOCATION_PAGED_IN, ARCH_PAGE_LOCATION_BAD }; enum arch_page_location arch_page_location_get(void *addr, uintptr_t *location); uintptr_t arch_page_info_get(void *addr, uintptr_t *location, _Bool clear_accessed); int arch_printk_char_out(int c); static inline void arch_kernel_init(void); static inline void arch_nop(void); void arch_coredump_info_dump(const z_arch_esf_t *esf); uint16_t arch_coredump_tgt_code_get(void); size_t arch_tls_stack_setup(struct k_thread *new_thread, char *stack_ptr); static inline __attribute__((always_inline)) _Bool arch_is_in_isr(void) { return arch_curr_cpu()->nested != 0U; } typedef struct __esf _esf_t; typedef struct __basic_sf _basic_sf_t; static inline __attribute__((always_inline)) void arch_kernel_init(void) { } static inline void arch_switch(void *switch_to, void **switched_from) { extern void z_arm64_context_switch(struct k_thread *new, struct k_thread *old); struct k_thread *new = switch_to; struct k_thread *old = ({ extern int (*__Static_assert_function (void)) [!!sizeof (struct { int __error_if_negative: (__builtin_types_compatible_p(__typeof__(*(switched_from)), __typeof__(((struct k_thread *)0)->switch_handle)) || __builtin_types_compatible_p(__typeof__(*(switched_from)), __typeof__(void))) ? 2 : -1; })]; ((struct k_thread *)(((char *)(switched_from)) - __builtin_offsetof (struct k_thread, switch_handle))); }); z_arm64_context_switch(new, old); } extern void z_arm64_fatal_error(unsigned int reason, z_arch_esf_t *esf); extern void z_arm64_set_ttbr0(uint64_t ttbr0); extern void z_arm64_mem_cfg_ipi(void); void z_arm64_flush_local_fpu(void); void z_arm64_flush_fpu_ipi(unsigned int cpu); extern void *memcpy (void *__restrict __dest, const void *__restrict __src, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); extern void *memmove (void *__dest, const void *__src, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))); extern int memcmp (const void *__s1, const void *__s2, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern void *memchr (const void *__s, int __c, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern char *strcpy (char *__restrict __dest, const char *__restrict __src) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); extern char *strncpy (char *__restrict __dest, const char *__restrict __src, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); extern char *strcat (char *__restrict __dest, const char *__restrict __src) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); extern char *strncat (char *__restrict __dest, const char *__restrict __src, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); extern int strcmp (const char *__s1, const char *__s2) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int strncmp (const char *__s1, const char *__s2, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int strcoll (const char *__s1, const char *__s2) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern size_t strxfrm (char *__restrict __dest, const char *__restrict __src, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 1, 3))); struct __locale_struct { struct __locale_data *__locales[13]; const unsigned short int *__ctype_b; const int *__ctype_tolower; const int *__ctype_toupper; const char *__names[13]; }; typedef struct __locale_struct *__locale_t; typedef __locale_t locale_t; extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, locale_t __l) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((__access__ (__write_only__, 1, 3))); extern char *strdup (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); extern char *strndup (const char *__string, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); extern char *strchr (const char *__s, int __c) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern char *strrchr (const char *__s, int __c) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern size_t strcspn (const char *__s, const char *__reject) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern size_t strspn (const char *__s, const char *__accept) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern char *strpbrk (const char *__s, const char *__accept) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern char *strstr (const char *__haystack, const char *__needle) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern char *strtok (char *__restrict __s, const char *__restrict __delim) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))); extern char *__strtok_r (char *__restrict __s, const char *__restrict __delim, char **__restrict __save_ptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3))); extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, char **__restrict __save_ptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3))); extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern size_t strnlen (const char *__string, size_t __maxlen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern char *strerror (int __errnum) __attribute__ ((__nothrow__ , __leaf__)); extern int strerror_r (int __errnum, char *__buf, size_t __buflen) __asm__ ("__USER_LABEL_PREFIX__" "__xpg_strerror_r") __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); extern char *strerror_l (int __errnum, locale_t __l) __attribute__ ((__nothrow__ , __leaf__)); extern char *strsignal (int __sig) __attribute__ ((__nothrow__ , __leaf__)); extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); extern char *__stpncpy (char *__restrict __dest, const char *__restrict __src, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); extern char *stpncpy (char *__restrict __dest, const char *__restrict __src, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void * __attribute__ ((__nothrow__ , __leaf__)) memcpy (void *__restrict __dest, const void *__restrict __src, size_t __len) { return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void * __attribute__ ((__nothrow__ , __leaf__)) memmove (void *__dest, const void *__src, size_t __len) { return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void * __attribute__ ((__nothrow__ , __leaf__)) memset (void *__dest, int __ch, size_t __len) { return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__nothrow__ , __leaf__)) strcpy (char *__restrict __dest, const char *__restrict __src) { return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 1 > 1)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__nothrow__ , __leaf__)) stpcpy (char *__restrict __dest, const char *__restrict __src) { return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 1 > 1)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__nothrow__ , __leaf__)) strncpy (char *__restrict __dest, const char *__restrict __src, size_t __len) { return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 1 > 1)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__nothrow__ , __leaf__)) stpncpy (char *__dest, const char *__src, size_t __n) { return __builtin___stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 1 > 1)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__nothrow__ , __leaf__)) strcat (char *__restrict __dest, const char *__restrict __src) { return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 1 > 1)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__nothrow__ , __leaf__)) strncat (char *__restrict __dest, const char *__restrict __src, size_t __len) { return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 1 > 1)); } void z_init_thread_base(struct _thread_base *thread_base, int priority, uint32_t initial_state, unsigned int options); void z_early_memset(void *dst, int c, size_t n); void z_early_memcpy(void *dst, const void *src, size_t n); void z_bss_zero(void); static inline void z_data_copy(void) { } static inline void z_bss_zero_boot(void) { } static inline void z_bss_zero_pinned(void) { } __attribute__((__noreturn__)) void z_cstart(void); void z_device_state_init(void); extern __attribute__((__noreturn__)) void z_thread_entry(k_thread_entry_t entry, void *p1, void *p2, void *p3); extern char *z_setup_new_thread(struct k_thread *new_thread, k_thread_stack_t *stack, size_t stack_size, k_thread_entry_t entry, void *p1, void *p2, void *p3, int prio, uint32_t options, const char *name); void *z_thread_aligned_alloc(size_t align, size_t size); static inline void *z_thread_malloc(size_t size) { return z_thread_aligned_alloc(0, size); } extern void z_thread_essential_set(void); extern void z_thread_essential_clear(void); static inline __attribute__((always_inline)) void arch_thread_return_value_set(struct k_thread *thread, unsigned int value) { thread->swap_retval = value; } static inline __attribute__((always_inline)) void z_thread_return_value_set_with_data(struct k_thread *thread, unsigned int value, void *data) { arch_thread_return_value_set(thread, value); thread->base.swap_data = data; } extern void z_early_rand_get(uint8_t *buf, size_t length); extern struct k_thread z_main_thread; extern struct k_thread z_idle_threads[1]; extern struct z_thread_stack_element z_interrupt_stacks[1][((((unsigned long)((((((unsigned long)(4096) + ((unsigned long)(16) - 1)) / (unsigned long)(16)) * (unsigned long)(16)) + ((size_t)0))) + ((unsigned long)(16) - 1)) / (unsigned long)(16)) * (unsigned long)(16))]; int z_stack_space_get(const uint8_t *stack_start, size_t size, size_t *unused_ptr); void z_mem_manage_init(void); void z_mem_manage_boot_finish(void); void z_handle_obj_poll_events(sys_dlist_t *events, uint32_t state); extern char _app_smem_start[]; extern char _app_smem_end[]; extern char _app_smem_size[]; extern char _app_smem_rom_start[]; extern char _app_smem_num_words[]; extern char __kernel_ram_start[]; extern char __kernel_ram_end[]; extern char __kernel_ram_size[]; extern char __bss_start[]; extern char __bss_end[]; extern char z_mapped_start[]; extern char z_mapped_end[]; extern char __rom_region_start[]; extern char __rom_region_end[]; extern char __rom_region_size[]; extern char _flash_used[]; extern char _image_ram_start[]; extern char _image_ram_end[]; extern char _image_ram_size[]; extern char __text_region_start[]; extern char __text_region_end[]; extern char __text_region_size[]; extern char __rodata_region_start[]; extern char __rodata_region_end[]; extern char __rodata_region_size[]; extern char _vector_start[]; extern char _vector_end[]; extern char _end[]; extern char __tdata_start[]; extern char __tdata_end[]; extern char __tdata_size[]; extern char __tdata_align[]; extern char __tbss_start[]; extern char __tbss_end[]; extern char __tbss_size[]; extern char __tbss_align[]; extern char __tls_start[]; extern char __tls_end[]; extern char __tls_size[]; static inline size_t z_tls_data_size(void) { size_t tdata_size = ((((unsigned long)(__tdata_size) + ((unsigned long)(__tdata_align) - 1)) / (unsigned long)(__tdata_align)) * (unsigned long)(__tdata_align)); size_t tbss_size = ((((unsigned long)(__tbss_size) + ((unsigned long)(__tbss_align) - 1)) / (unsigned long)(__tbss_align)) * (unsigned long)(__tbss_align)); return tdata_size + tbss_size; } static inline void z_tls_copy(char *dest) { size_t tdata_size = (size_t)__tdata_size; size_t tbss_size = (size_t)__tbss_size; memcpy(dest, __tdata_start, tdata_size); dest += ((((unsigned long)(tdata_size) + ((unsigned long)(__tdata_align) - 1)) / (unsigned long)(__tdata_align)) * (unsigned long)(__tdata_align)); memset(dest, 0, tbss_size); } size_t arch_tls_stack_setup(struct k_thread *new_thread, char *stack_ptr) { stack_ptr -= z_tls_data_size(); z_tls_copy(stack_ptr); stack_ptr -= sizeof(uintptr_t) * 2; new_thread->tls = ((uintptr_t) (stack_ptr)); return (z_tls_data_size() + (sizeof(uintptr_t) * 2)); }
