2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
12 * You should have received a copy of the GNU General Public License along
13 * with this program; if not, write to the Free Software Foundation, Inc.,
14 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 #ifndef __SHARED_COMPILER_H
18 #define __SHARED_COMPILER_H
20 #define __noreturn __attribute__((noreturn))
21 #define __inline __attribute__((always_inline))
22 #define __hot __attribute__((hot))
23 #define __cold __attribute__((cold))
25 #define __in_section(s) __attribute__((section("." # s)))
26 #define __visible __attribute__((externally_visible))
27 #ifndef __attribute_const__
28 #define __attribute_const__ __attribute__((__const__))
32 #include "little_endian.h"
34 #define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
36 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
37 #define BUILD_BUG_ON_ZERO(e) (sizeof(char[1 - 2 * !!(e)]) - 1)
39 #define ALIGN(x, a) __ALIGN_MASK(x, (typeof(x))(a) - 1)
40 #define __ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
42 #define __roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
44 #define __must_be_array(a) \
45 BUILD_BUG_ON_ZERO(__builtin_types_compatible_p(typeof(a), typeof(&a[0])))
46 #define ARRAY_SIZE(arr) (sizeof((arr)) / sizeof((arr)[0]) + __must_be_array(arr))
48 #define BIT(b) (1 << (b))
49 #define MASK(w) (BIT(w) - 1)
52 * __struct_group() - Create a mirrored named and anonyomous struct
54 * @TAG: The tag name for the named sub-struct (usually empty)
55 * @NAME: The identifier name of the mirrored sub-struct
56 * @ATTRS: Any struct attributes (usually empty)
57 * @MEMBERS: The member declarations for the mirrored structs
59 * Used to create an anonymous union of two structs with identical layout
60 * and size: one anonymous and one named. The former's members can be used
61 * normally without sub-struct naming, and the latter can be used to
62 * reason about the start, end, and size of the group of struct members.
63 * The named struct can also be explicitly tagged for layer reuse, as well
64 * as both having struct attributes appended.
66 #define __struct_group(TAG, NAME, ATTRS, MEMBERS...) \
68 struct { MEMBERS } ATTRS; \
69 struct TAG { MEMBERS } ATTRS NAME; \
73 * struct_group() - Wrap a set of declarations in a mirrored struct
75 * @NAME: The identifier name of the mirrored sub-struct
76 * @MEMBERS: The member declarations for the mirrored structs
78 * Used to create an anonymous union of two structs with identical
79 * layout and size: one anonymous and one named. The former can be
80 * used normally without sub-struct naming, and the latter can be
81 * used to reason about the start, end, and size of the group of
84 #define struct_group(NAME, MEMBERS...) \
85 __struct_group(/* no tag */, NAME, /* no attrs */, MEMBERS)
88 #ifdef __compiler_offsetof
89 # define offsetof(TYPE, MEMBER) __compiler_offsetof(TYPE, MEMBER)
91 # define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
95 * sizeof_field() - Report the size of a struct field in bytes
97 * @TYPE: The structure containing the field of interest
98 * @MEMBER: The field to return the size of
100 #define sizeof_field(TYPE, MEMBER) sizeof((((TYPE *)0)->MEMBER))
103 * offsetofend() - Report the offset of a struct field within the struct
105 * @TYPE: The type of the structure
106 * @MEMBER: The member within the structure to get the end offset of
108 #define offsetofend(TYPE, MEMBER) \
109 (offsetof(TYPE, MEMBER) + sizeof_field(TYPE, MEMBER))
111 #define likely(x) __builtin_expect(!!(x), 1)
112 #define unlikely(x) __builtin_expect(!!(x), 0)
114 #define min(x, y) ({ \
115 typeof(x) _min1 = (x); \
116 typeof(y) _min2 = (y); \
117 (void) (&_min1 == &_min2); \
118 _min1 < _min2 ? _min1 : _min2; })
120 #define max(x, y) ({ \
121 typeof(x) _max1 = (x); \
122 typeof(y) _max2 = (y); \
123 (void) (&_max1 == &_max2); \
124 _max1 > _max2 ? _max1 : _max2; })
126 #define min_t(type, x, y) ({ \
129 __min1 < __min2 ? __min1 : __min2; })
131 #define max_t(type, x, y) ({ \
134 __max1 > __max2 ? __max1 : __max2; })
137 #define container_of(ptr, type, member) ({ \
138 const typeof(((type *)0)->member) * __mptr = (ptr); \
139 (type *)(((unsigned long)__mptr - offsetof(type, member))); })
141 #define MAX_ERRNO 4095
143 #define IS_ERR_VALUE(x) unlikely((x) >= (unsigned long)-MAX_ERRNO)
145 static inline void *ERR_PTR(long errornr)
147 return (void *) errornr;
150 static inline long PTR_ERR(const void *ptr)
155 static inline long IS_ERR(const void *ptr)
157 return IS_ERR_VALUE((unsigned long)ptr);
160 static inline long IS_ERR_OR_NULL(const void *ptr)
162 return !ptr || IS_ERR_VALUE((unsigned long)ptr);
165 static inline unsigned int hweight8(unsigned int w)
167 unsigned int res = w - ((w >> 1) & 0x55);
168 res = (res & 0x33) + ((res >> 2) & 0x33);
169 return (res + (res >> 4)) & 0x0F;
172 static inline unsigned int hweight16(unsigned int w)
174 unsigned int res = w - ((w >> 1) & 0x5555);
175 res = (res & 0x3333) + ((res >> 2) & 0x3333);
176 res = (res + (res >> 4)) & 0x0F0F;
177 return (res + (res >> 8)) & 0x00FF;
181 * DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union
183 * @TYPE: The type of each flexible array element
184 * @NAME: The name of the flexible array member
186 * In order to have a flexible array member in a union or alone in a
187 * struct, it needs to be wrapped in an anonymous struct with at least 1
188 * named member, but that member can be empty.
190 #define DECLARE_FLEX_ARRAY(TYPE, NAME) \
192 struct { } __empty_ ## NAME; \
196 #define __bf_shf(x) (__builtin_ffsll(x) - 1)
198 #define FIELD_MAX(_mask) \
200 (typeof(_mask))((_mask) >> __bf_shf(_mask)); \
203 #if __has_attribute(__error__)
204 # define __compiletime_error(msg) __attribute__((__error__(msg)))
206 # define __compiletime_error(msg)
209 extern void __compiletime_error("value doesn't fit into mask")
210 __field_overflow(void);
211 extern void __compiletime_error("bad bitfield mask")
213 static inline u64 field_multiplier(u32 field)
215 if ((field | (field - 1)) & ((field | (field - 1)) + 1))
217 return field & -field;
219 static inline u64 field_mask(const u32 field)
221 return field / field_multiplier(field);
223 #define field_max(field) ((typeof(field))field_mask(field))
224 #define ____MAKE_OP(type,base,to,from) \
225 static inline __##type type##_encode_bits(base v, base field) \
227 if (__builtin_constant_p(v) && (v & ~field_mask(field))) \
228 __field_overflow(); \
229 return to((v & field_mask(field)) * field_multiplier(field)); \
231 static inline __##type type##_replace_bits(__##type old, \
232 base val, base field) \
234 return (old & ~to(field)) | type##_encode_bits(val, field); \
236 static inline void type##p_replace_bits(__##type *p, \
237 base val, base field) \
239 *p = (*p & ~to(field)) | type##_encode_bits(val, field); \
241 static inline base type##_get_bits(__##type v, base field) \
243 return (from(v) & field)/field_multiplier(field); \
245 #define __MAKE_OP(size) \
246 ____MAKE_OP(le##size,u##size,cpu_to_le##size,le##size##_to_cpu) \
247 ____MAKE_OP(be##size,u##size,cpu_to_be##size,be##size##_to_cpu) \
248 ____MAKE_OP(u##size,u##size,,)
255 #endif /* __SHARED_COMPILER_H */