rt 0.19.1

A real-time operating system capable of full preemption
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

#pragma once

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

// No atomic qualifier.
#define _Atomic volatile

typedef _Atomic bool atomic_bool;
typedef _Atomic bool atomic_flag;
typedef _Atomic unsigned char atomic_uchar;
typedef _Atomic int atomic_int;
typedef _Atomic unsigned int atomic_uint;
typedef _Atomic size_t atomic_size_t;
typedef _Atomic uintptr_t atomic_uintptr_t;
typedef _Atomic long atomic_long;
typedef _Atomic unsigned long atomic_ulong;
typedef _Atomic uint32_t atomic_uint32_t;

#define ATOMIC_FLAG_INIT false

typedef enum
{
    memory_order_relaxed,
    memory_order_consume,
    memory_order_acquire,
    memory_order_release,
    memory_order_acq_rel,
    memory_order_seq_cst,
} memory_order;

extern __cregister volatile uint16_t IER;

static inline uint16_t __ier_disable(void)
{
    const uint16_t mask = IER;
    IER = 0;
    return mask;
}

static inline void __ier_restore(uint16_t mask)
{
    IER = mask;
}

#define atomic_load(p) (*(p))

#define atomic_load_explicit(p, mo) atomic_load(p)

#define atomic_store(p, v) (*(p) = (v))

#define atomic_store_explicit(p, v, mo) atomic_store(p, v)

#define atomic_exchange_explicit(p, v, mo)                                     \
    ({                                                                         \
        const uint16_t mask = __ier_disable();                                 \
        const __typeof__(*(p)) o = *(p);                                       \
        *(p) = (v);                                                            \
        __ier_restore(mask);                                                   \
        o;                                                                     \
    })

#define atomic_fetch_add_explicit(p, v, mo)                                    \
    ({                                                                         \
        const uint16_t mask = __ier_disable();                                 \
        const __typeof__(*(p)) o = *(p);                                       \
        *(p) += (v);                                                           \
        __ier_restore(mask);                                                   \
        o;                                                                     \
    })

#define atomic_fetch_sub_explicit(p, v, mo)                                    \
    ({                                                                         \
        const uint16_t mask = __ier_disable();                                 \
        const __typeof__(*(p)) o = *(p);                                       \
        *(p) -= (v);                                                           \
        __ier_restore(mask);                                                   \
        o;                                                                     \
    })

#define atomic_fetch_or_explicit(p, v, mo)                                     \
    ({                                                                         \
        const uint16_t mask = __ier_disable();                                 \
        const __typeof__(*(p)) o = *(p);                                       \
        *(p) |= (v);                                                           \
        __ier_restore(mask);                                                   \
        o;                                                                     \
    })

#define atomic_fetch_and_explicit(p, v, mo)                                    \
    ({                                                                         \
        const uint16_t mask = __ier_disable();                                 \
        const __typeof__(*(p)) o = *(p);                                       \
        *(p) &= (v);                                                           \
        __ier_restore(mask);                                                   \
        o;                                                                     \
    })

#define atomic_compare_exchange_strong_explicit(p, e, v, mos, mof)             \
    ({                                                                         \
        const uint16_t mask = __ier_disable();                                 \
        const __typeof__(v) o = *(p);                                          \
        const bool equal = o == *(e);                                          \
        if (equal)                                                             \
        {                                                                      \
            *(p) = (v);                                                        \
        }                                                                      \
        else                                                                   \
        {                                                                      \
            *(e) = o;                                                          \
        }                                                                      \
        __ier_restore(mask);                                                   \
        equal;                                                                 \
    })

#define atomic_compare_exchange_weak_explicit                                  \
    atomic_compare_exchange_strong_explicit

#define atomic_flag_test_and_set_explicit(p, mo)                               \
    ({                                                                         \
        const uint16_t mask = __ier_disable();                                 \
        const bool o = *(p);                                                   \
        *(p) = true;                                                           \
        __ier_restore(mask);                                                   \
        o;                                                                     \
    })

#define atomic_flag_clear_explicit(p, mo) ({ *(p) = false; })