include/linux/compiler.h

   1 /*
   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.
   6  *
   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.
  11  *
  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.
  15  */
  16
  17 #ifndef __SHARED_COMPILER_H
  18 #define __SHARED_COMPILER_H
  19
  20 #define __noreturn      __attribute__((noreturn))
  21 #define __inline        __attribute__((always_inline))
  22 #define __hot           __attribute__((hot))
  23 #define __cold          __attribute__((cold))
  24 #define __force         __attribute__((force))
  25 #define __in_section(s) __attribute__((section("." # s)))
  26 #define __visible       __attribute__((externally_visible))
  27
  28 #define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
  29
  30
  31 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
  32 #define BUILD_BUG_ON_ZERO(e) (sizeof(char[1 - 2 * !!(e)]) - 1)
  33
  34 #define ALIGN(x, a)             __ALIGN_MASK(x, (typeof(x))(a) - 1)
  35 #define __ALIGN_MASK(x, mask)   (((x) + (mask)) & ~(mask))
  36
  37 #define __roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
  38
  39 #define __must_be_array(a) \
  40   BUILD_BUG_ON_ZERO(__builtin_types_compatible_p(typeof(a), typeof(&a[0])))
  41 #define ARRAY_SIZE(arr) (sizeof((arr)) / sizeof((arr)[0]) + __must_be_array(arr))
  42
  43 #define BIT(b)                  (1 << (b))
  44 #define MASK(w)                 (BIT(w) - 1)
  45
  46 /**
  47  * __struct_group() - Create a mirrored named and anonyomous struct
  48  *
  49  * @TAG: The tag name for the named sub-struct (usually empty)
  50  * @NAME: The identifier name of the mirrored sub-struct
  51  * @ATTRS: Any struct attributes (usually empty)
  52  * @MEMBERS: The member declarations for the mirrored structs
  53  *
  54  * Used to create an anonymous union of two structs with identical layout
  55  * and size: one anonymous and one named. The former's members can be used
  56  * normally without sub-struct naming, and the latter can be used to
  57  * reason about the start, end, and size of the group of struct members.
  58  * The named struct can also be explicitly tagged for layer reuse, as well
  59  * as both having struct attributes appended.
  60  */
  61 #define __struct_group(TAG, NAME, ATTRS, MEMBERS...) \
  62         union { \
  63                 struct { MEMBERS } ATTRS; \
  64                 struct TAG { MEMBERS } ATTRS NAME; \
  65         }
  66
  67 /**
  68  * struct_group() - Wrap a set of declarations in a mirrored struct
  69  *
  70  * @NAME: The identifier name of the mirrored sub-struct
  71  * @MEMBERS: The member declarations for the mirrored structs
  72  *
  73  * Used to create an anonymous union of two structs with identical
  74  * layout and size: one anonymous and one named. The former can be
  75  * used normally without sub-struct naming, and the latter can be
  76  * used to reason about the start, end, and size of the group of
  77  * struct members.
  78  */
  79 #define struct_group(NAME, MEMBERS...)  \
  80         __struct_group(/* no tag */, NAME, /* no attrs */, MEMBERS)
  81
  82 #undef offsetof
  83 #ifdef __compiler_offsetof
  84 # define offsetof(TYPE, MEMBER) __compiler_offsetof(TYPE, MEMBER)
  85 #else
  86 # define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
  87 #endif
  88
  89 /**
  90  * sizeof_field() - Report the size of a struct field in bytes
  91  *
  92  * @TYPE: The structure containing the field of interest
  93  * @MEMBER: The field to return the size of
  94  */
  95 #define sizeof_field(TYPE, MEMBER) sizeof((((TYPE *)0)->MEMBER))
  96
  97 /**
  98  * offsetofend() - Report the offset of a struct field within the struct
  99  *
 100  * @TYPE: The type of the structure
 101  * @MEMBER: The member within the structure to get the end offset of
 102  */
 103 #define offsetofend(TYPE, MEMBER) \
 104         (offsetof(TYPE, MEMBER) + sizeof_field(TYPE, MEMBER))
 105
 106 #define likely(x)       __builtin_expect(!!(x), 1)
 107 #define unlikely(x)     __builtin_expect(!!(x), 0)
 108
 109 #define min(x, y) ({                            \
 110         typeof(x) _min1 = (x);                  \
 111         typeof(y) _min2 = (y);                  \
 112         (void) (&_min1 == &_min2);              \
 113         _min1 < _min2 ? _min1 : _min2; })
 114
 115 #define max(x, y) ({                            \
 116         typeof(x) _max1 = (x);                  \
 117         typeof(y) _max2 = (y);                  \
 118         (void) (&_max1 == &_max2);              \
 119         _max1 > _max2 ? _max1 : _max2; })
 120
 121 #define min_t(type, x, y) ({                    \
 122         type __min1 = (x);                      \
 123         type __min2 = (y);                      \
 124         __min1 < __min2 ? __min1 : __min2; })
 125
 126 #define max_t(type, x, y) ({                    \
 127         type __max1 = (x);                      \
 128         type __max2 = (y);                      \
 129         __max1 > __max2 ? __max1 : __max2; })
 130
 131
 132 #define container_of(ptr, type, member) ({                      \
 133         const typeof(((type *)0)->member) * __mptr = (ptr);     \
 134         (type *)(((unsigned long)__mptr - offsetof(type, member))); })
 135
 136 #define MAX_ERRNO       4095
 137
 138 #define IS_ERR_VALUE(x) unlikely((x) >= (unsigned long)-MAX_ERRNO)
 139
 140 static inline void *ERR_PTR(long errornr)
 141 {
 142         return (void *) errornr;
 143 }
 144
 145 static inline long PTR_ERR(const void *ptr)
 146 {
 147         return (long) ptr;
 148 }
 149
 150 static inline long IS_ERR(const void *ptr)
 151 {
 152         return IS_ERR_VALUE((unsigned long)ptr);
 153 }
 154
 155 static inline long IS_ERR_OR_NULL(const void *ptr)
 156 {
 157         return !ptr || IS_ERR_VALUE((unsigned long)ptr);
 158 }
 159
 160 static inline unsigned int hweight8(unsigned int w)
 161 {
 162         unsigned int res = w - ((w >> 1) & 0x55);
 163         res = (res & 0x33) + ((res >> 2) & 0x33);
 164         return (res + (res >> 4)) & 0x0F;
 165 }
 166
 167 static inline unsigned int hweight16(unsigned int w)
 168 {
 169         unsigned int res = w - ((w >> 1) & 0x5555);
 170         res = (res & 0x3333) + ((res >> 2) & 0x3333);
 171         res = (res + (res >> 4)) & 0x0F0F;
 172         return (res + (res >> 8)) & 0x00FF;
 173 }
 174
 175 /**
 176  * DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union
 177  *
 178  * @TYPE: The type of each flexible array element
 179  * @NAME: The name of the flexible array member
 180  *
 181  * In order to have a flexible array member in a union or alone in a
 182  * struct, it needs to be wrapped in an anonymous struct with at least 1
 183  * named member, but that member can be empty.
 184  */
 185 #define DECLARE_FLEX_ARRAY(TYPE, NAME)  \
 186         struct { \
 187                 struct { } __empty_ ## NAME; \
 188                 TYPE NAME[]; \
 189         }
 190
 191 #define __bf_shf(x) (__builtin_ffsll(x) - 1)
 192
 193 #define FIELD_MAX(_mask)                                                \
 194         ({                                                              \
 195                 (typeof(_mask))((_mask) >> __bf_shf(_mask));            \
 196         })
 197
 198 #if __has_attribute(__error__)
 199 # define __compiletime_error(msg)       __attribute__((__error__(msg)))
 200 #else
 201 # define __compiletime_error(msg)
 202 #endif
 203
 204 extern void __compiletime_error("value doesn't fit into mask")
 205 __field_overflow(void);
 206 extern void __compiletime_error("bad bitfield mask")
 207 __bad_mask(void);
 208 static inline u64 field_multiplier(u32 field)
 209 {
 210         if ((field | (field - 1)) & ((field | (field - 1)) + 1))
 211                 __bad_mask();
 212         return field & -field;
 213 }
 214 static inline u64 field_mask(const u32 field)
 215 {
 216         return field / field_multiplier(field);
 217 }
 218 #define field_max(field)        ((typeof(field))field_mask(field))
 219 #define ____MAKE_OP(type,base,to,from)                                  \
 220 static inline __##type type##_encode_bits(base v, base field)   \
 221 {                                                                       \
 222         if (__builtin_constant_p(v) && (v & ~field_mask(field)))        \
 223                 __field_overflow();                                     \
 224         return to((v & field_mask(field)) * field_multiplier(field));   \
 225 }                                                                       \
 226 static inline __##type type##_replace_bits(__##type old,        \
 227                                         base val, base field)           \
 228 {                                                                       \
 229         return (old & ~to(field)) | type##_encode_bits(val, field);     \
 230 }                                                                       \
 231 static inline void type##p_replace_bits(__##type *p,            \
 232                                         base val, base field)           \
 233 {                                                                       \
 234         *p = (*p & ~to(field)) | type##_encode_bits(val, field);        \
 235 }                                                                       \
 236 static inline base type##_get_bits(__##type v, base field)      \
 237 {                                                                       \
 238         return (from(v) & field)/field_multiplier(field);               \
 239 }
 240 #define __MAKE_OP(size)                                                 \
 241         ____MAKE_OP(le##size,u##size,cpu_to_le##size,le##size##_to_cpu) \
 242         ____MAKE_OP(u##size,u##size,,)
 243 ____MAKE_OP(u8,u8,,)
 244 __MAKE_OP(16)
 245 __MAKE_OP(32)
 246 #undef __MAKE_OP
 247 #undef ____MAKE_OP
 248
 249 #endif /* __SHARED_COMPILER_H */