TA-REF
compiler.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2014, STMicroelectronics International N.V.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation
13 * and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
19 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 * POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#ifndef COMPILER_H
29#define COMPILER_H
30
31#ifndef DOXYGEN_SHOULD_SKIP_THIS
32/*
33 * Macros that should be used instead of using __attribute__ directly to
34 * ease portability and make the code easier to read.
35 */
36
37#define __deprecated __attribute__((deprecated))
38#define __packed __attribute__((packed))
39#define __weak __attribute__((weak))
40#define __noreturn __attribute__((noreturn))
41#define __pure __attribute__((pure))
42#define __aligned(x) __attribute__((aligned(x)))
43#define __printf(a, b) __attribute__((format(printf, a, b)))
44#define __noinline __attribute__((noinline))
45#define __attr_const __attribute__((__const__))
46#define __unused __attribute__((unused))
47#define __maybe_unused __attribute__((unused))
48#define __used __attribute__((__used__))
49#define __must_check __attribute__((warn_unused_result))
50#define __cold __attribute__((__cold__))
51#define __section(x) __attribute__((section(x)))
52#define __data __section(".data")
53#define __bss __section(".bss")
54#define __rodata __section(".rodata")
55#define __rodata_unpaged __section(".rodata.__unpaged")
56#define __early_ta __section(".rodata.early_ta")
57#define __noprof __attribute__((no_instrument_function))
58
59#define __compiler_bswap64(x) __builtin_bswap64((x))
60#define __compiler_bswap32(x) __builtin_bswap32((x))
61#define __compiler_bswap16(x) __builtin_bswap16((x))
62
63#define __GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + \
64 __GNUC_PATCHLEVEL__)
65
66#if __GCC_VERSION >= 50100 && !defined(__CHECKER__)
67#define __HAVE_BUILTIN_OVERFLOW 1
68#endif
69
70#ifdef __HAVE_BUILTIN_OVERFLOW
71#define __compiler_add_overflow(a, b, res) \
72 __builtin_add_overflow((a), (b), (res))
73
74#define __compiler_sub_overflow(a, b, res) \
75 __builtin_sub_overflow((a), (b), (res))
76
77#define __compiler_mul_overflow(a, b, res) \
78 __builtin_mul_overflow((a), (b), (res))
79#else
81/*
82 * Copied/inspired from https://www.fefe.de/intof.html
83 */
84#define __INTOF_HALF_MAX_SIGNED(type) ((type)1 << (sizeof(type)*8-2))
85#define __INTOF_MAX_SIGNED(type) (__INTOF_HALF_MAX_SIGNED(type) - 1 + \
86 __INTOF_HALF_MAX_SIGNED(type))
87#define __INTOF_MIN_SIGNED(type) (-1 - __INTOF_MAX_SIGNED(type))
88
89#define __INTOF_MIN(type) ((type)-1 < 1?__INTOF_MIN_SIGNED(type):(type)0)
90#define __INTOF_MAX(type) ((type)~__INTOF_MIN(type))
91
92#define __INTOF_ASSIGN(dest, src) (__extension__({ \
93 typeof(src) __intof_x = (src); \
94 typeof(dest) __intof_y = __intof_x; \
95 (((uintmax_t)__intof_x == (uintmax_t)__intof_y) && \
96 ((__intof_x < 1) == (__intof_y < 1)) ? \
97 (void)((dest) = __intof_y) , 0 : 1); \
98}))
99
100#define __INTOF_ADD(c, a, b) (__extension__({ \
101 typeof(a) __intofa_a = (a); \
102 typeof(b) __intofa_b = (b); \
103 \
104 __intofa_b < 1 ? \
105 ((__INTOF_MIN(typeof(c)) - __intofa_b <= __intofa_a) ? \
106 __INTOF_ASSIGN((c), __intofa_a + __intofa_b) : 1) : \
107 ((__INTOF_MAX(typeof(c)) - __intofa_b >= __intofa_a) ? \
108 __INTOF_ASSIGN((c), __intofa_a + __intofa_b) : 1); \
109}))
110
111#define __INTOF_SUB(c, a, b) (__extension__({ \
112 typeof(a) __intofs_a = a; \
113 typeof(b) __intofs_b = b; \
114 \
115 __intofs_b < 1 ? \
116 ((__INTOF_MAX(typeof(c)) + __intofs_b >= __intofs_a) ? \
117 __INTOF_ASSIGN((c), __intofs_a - __intofs_b) : 1) : \
118 ((__INTOF_MIN(typeof(c)) + __intofs_b <= __intofs_a) ? \
119 __INTOF_ASSIGN((c), __intofs_a - __intofs_b) : 1); \
120}))
121
122/*
123 * Dealing with detecting overflow in multiplication of integers.
124 *
125 * First step is to remove two corner cases with the minum signed integer
126 * which can't be represented as a positive integer + sign.
127 * Multiply with 0 or 1 can't overflow, no checking needed of the operation,
128 * only if it can be assigned to the result.
129 *
130 * After the corner cases are eliminated we convert the two factors to
131 * positive unsigned values, keeping track of the original in another
132 * variable which is used at the end to determine the sign of the product.
133 *
134 * The two terms (a and b) are divided into upper and lower half (x1 upper
135 * and x0 lower), so the product is:
136 * ((a1 << hshift) + a0) * ((b1 << hshift) + b0)
137 * which also is:
138 * ((a1 * b1) << (hshift * 2)) + (T1)
139 * ((a1 * b0 + a0 * b1) << hshift) + (T2)
140 * (a0 * b0) (T3)
141 *
142 * From this we can tell and (a1 * b1) has to be 0 or we'll overflow, that
143 * is, at least one of a1 or b1 has to be 0. Once this has been checked the
144 * addition: ((a1 * b0) << hshift) + ((a0 * b1) << hshift)
145 * isn't an addition as one of the terms will be 0.
146 *
147 * Since each factor in: (a0 * b0)
148 * only uses half the capicity of the underlaying type it can't overflow
149 *
150 * The addition of T2 and T3 can overflow so we use __INTOF_ADD() to
151 * perform that addition. If the addition succeeds without overflow the
152 * result is assigned the required sign and checked for overflow again.
153 */
154
155#define __intof_mul_negate ((__intof_oa < 1) != (__intof_ob < 1))
156#define __intof_mul_hshift (sizeof(uintmax_t) * 8 / 2)
157#define __intof_mul_hmask (UINTMAX_MAX >> __intof_mul_hshift)
158#define __intof_mul_a0 ((uintmax_t)(__intof_a) >> __intof_mul_hshift)
159#define __intof_mul_b0 ((uintmax_t)(__intof_b) >> __intof_mul_hshift)
160#define __intof_mul_a1 ((uintmax_t)(__intof_a) & __intof_mul_hmask)
161#define __intof_mul_b1 ((uintmax_t)(__intof_b) & __intof_mul_hmask)
162#define __intof_mul_t (__intof_mul_a1 * __intof_mul_b0 + \
163 __intof_mul_a0 * __intof_mul_b1)
164
165#define __INTOF_MUL(c, a, b) (__extension__({ \
166 typeof(a) __intof_oa = (a); \
167 typeof(a) __intof_a = __intof_oa < 1 ? -__intof_oa : __intof_oa; \
168 typeof(b) __intof_ob = (b); \
169 typeof(b) __intof_b = __intof_ob < 1 ? -__intof_ob : __intof_ob; \
170 typeof(c) __intof_c; \
171 \
172 __intof_oa == 0 || __intof_ob == 0 || \
173 __intof_oa == 1 || __intof_ob == 1 ? \
174 __INTOF_ASSIGN((c), __intof_oa * __intof_ob) : \
175 (__intof_mul_a0 && __intof_mul_b0) || \
176 __intof_mul_t > __intof_mul_hmask ? 1 : \
177 __INTOF_ADD((__intof_c), __intof_mul_t << __intof_mul_hshift, \
178 __intof_mul_a1 * __intof_mul_b1) ? 1 : \
179 __intof_mul_negate ? __INTOF_ASSIGN((c), -__intof_c) : \
180 __INTOF_ASSIGN((c), __intof_c); \
181}))
182
183#define __compiler_add_overflow(a, b, res) __INTOF_ADD(*(res), (a), (b))
184#define __compiler_sub_overflow(a, b, res) __INTOF_SUB(*(res), (a), (b))
185#define __compiler_mul_overflow(a, b, res) __INTOF_MUL(*(res), (a), (b))
186
187#endif
189#define __compiler_compare_and_swap(p, oval, nval) \
190 __atomic_compare_exchange_n((p), (oval), (nval), true, \
191 __ATOMIC_ACQUIRE, __ATOMIC_RELAXED) \
192
193#define __compiler_atomic_load(p) __atomic_load_n((p), __ATOMIC_RELAXED)
194#define __compiler_atomic_store(p, val) \
195 __atomic_store_n((p), (val), __ATOMIC_RELAXED)
196
197#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
198#endif /*COMPILER_H*/