ofproto: Inline actions in struct rule_actions.
[sliver-openvswitch.git] / lib / compiler.h
1 /*
2  * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #ifndef COMPILER_H
18 #define COMPILER_H 1
19
20 #ifndef __has_feature
21   #define __has_feature(x) 0
22 #endif
23 #ifndef __has_extension
24   #define __has_extension(x) 0
25 #endif
26
27 #if __GNUC__ && !__CHECKER__
28 #define NO_RETURN __attribute__((__noreturn__))
29 #define OVS_UNUSED __attribute__((__unused__))
30 #define PRINTF_FORMAT(FMT, ARG1) __attribute__((__format__(printf, FMT, ARG1)))
31 #define SCANF_FORMAT(FMT, ARG1) __attribute__((__format__(scanf, FMT, ARG1)))
32 #define STRFTIME_FORMAT(FMT) __attribute__((__format__(__strftime__, FMT, 0)))
33 #define MALLOC_LIKE __attribute__((__malloc__))
34 #define ALWAYS_INLINE __attribute__((always_inline))
35 #define WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
36 #define SENTINEL(N) __attribute__((sentinel(N)))
37 #define OVS_LIKELY(CONDITION) __builtin_expect(!!(CONDITION), 1)
38 #define OVS_UNLIKELY(CONDITION) __builtin_expect(!!(CONDITION), 0)
39 #else
40 #define NO_RETURN
41 #define OVS_UNUSED
42 #define PRINTF_FORMAT(FMT, ARG1)
43 #define SCANF_FORMAT(FMT, ARG1)
44 #define STRFTIME_FORMAT(FMT)
45 #define MALLOC_LIKE
46 #define ALWAYS_INLINE
47 #define WARN_UNUSED_RESULT
48 #define SENTINEL(N)
49 #define OVS_LIKELY(CONDITION) (!!(CONDITION))
50 #define OVS_UNLIKELY(CONDITION) (!!(CONDITION))
51 #endif
52
53 #if __has_feature(c_thread_safety_attributes)
54 /* "clang" annotations for thread safety check.
55  *
56  * OVS_LOCKABLE indicates that the struct contains mutex element
57  * which can be locked by functions like ovs_mutex_lock().
58  *
59  * Below, the word MUTEX stands for the name of an object with an OVS_LOCKABLE
60  * struct type.  It can also be a comma-separated list of multiple structs,
61  * e.g. to require a function to hold multiple locks while invoked.
62  *
63  *
64  * On a variable:
65  *
66  *    - OVS_GUARDED indicates that the variable may only be accessed some mutex
67  *      is held.
68  *
69  *    - OVS_GUARDED_BY(MUTEX) indicates that the variable may only be accessed
70  *      while the specific MUTEX is held.
71  *
72  *
73  * On a variable A of mutex type:
74  *
75  *    - OVS_ACQ_BEFORE(B), where B is a mutex or a comma-separated list of
76  *      mutexes, declare that if both A and B are acquired at the same time,
77  *      then A must be acquired before B.  That is, B nests inside A.
78  *
79  *    - OVS_ACQ_AFTER(B) is the opposite of OVS_ACQ_BEFORE(B), that is, it
80  *      declares that A nests inside B.
81  *
82  *
83  * On a function, the following attributes apply to mutexes:
84  *
85  *    - OVS_ACQUIRES(MUTEX) indicate that the function must be called without
86  *      holding MUTEX and that it returns holding MUTEX.
87  *
88  *    - OVS_RELEASES(MUTEX) indicates that the function may only be called with
89  *      MUTEX held and that it returns with MUTEX released.  It can be used for
90  *      all types of MUTEX.
91  *
92  *    - OVS_TRY_LOCK(RETVAL, MUTEX) indicate that the function will try to
93  *      acquire MUTEX.  RETVAL is an integer or boolean value specifying the
94  *      return value of a successful lock acquisition.
95  *
96  *    - OVS_REQUIRES(MUTEX) indicate that the function may only be called with
97  *      MUTEX held and that the function does not release MUTEX.
98  *
99  *    - OVS_EXCLUDED(MUTEX) indicates that the function may only be called when
100  *      MUTEX is not held.
101  *
102  *
103  * The following variants, with the same syntax, apply to reader-writer locks:
104  *
105  *    mutex                rwlock, for reading  rwlock, for writing
106  *    -------------------  -------------------  -------------------
107  *    OVS_ACQUIRES         OVS_ACQ_RDLOCK       OVS_ACQ_WRLOCK
108  *    OVS_RELEASES         OVS_RELEASES         OVS_RELEASES
109  *    OVS_TRY_LOCK         OVS_TRY_RDLOCK       OVS_TRY_WRLOCK
110  *    OVS_REQUIRES         OVS_REQ_RDLOCK       OVS_REQ_WRLOCK
111  *    OVS_EXCLUDED         OVS_EXCLUDED         OVS_EXCLUDED
112  */
113 #define OVS_LOCKABLE __attribute__((lockable))
114 #define OVS_REQ_RDLOCK(...) __attribute__((shared_locks_required(__VA_ARGS__)))
115 #define OVS_ACQ_RDLOCK(...) __attribute__((shared_lock_function(__VA_ARGS__)))
116 #define OVS_REQ_WRLOCK(...) \
117     __attribute__((exclusive_locks_required(__VA_ARGS__)))
118 #define OVS_ACQ_WRLOCK(...) \
119     __attribute__((exclusive_lock_function(__VA_ARGS__)))
120 #define OVS_REQUIRES(...) \
121     __attribute__((exclusive_locks_required(__VA_ARGS__)))
122 #define OVS_ACQUIRES(...) \
123     __attribute__((exclusive_lock_function(__VA_ARGS__)))
124 #define OVS_TRY_WRLOCK(RETVAL, ...)                              \
125     __attribute__((exclusive_trylock_function(RETVAL, __VA_ARGS__)))
126 #define OVS_TRY_RDLOCK(RETVAL, ...)                          \
127     __attribute__((shared_trylock_function(RETVAL, __VA_ARGS__)))
128 #define OVS_TRY_LOCK(RETVAL, ...)                                \
129     __attribute__((exclusive_trylock_function(RETVAL, __VA_ARGS__)))
130 #define OVS_GUARDED __attribute__((guarded_var))
131 #define OVS_GUARDED_BY(...) __attribute__((guarded_by(__VA_ARGS__)))
132 #define OVS_RELEASES(...) __attribute__((unlock_function(__VA_ARGS__)))
133 #define OVS_EXCLUDED(...) __attribute__((locks_excluded(__VA_ARGS__)))
134 #define OVS_ACQ_BEFORE(...) __attribute__((acquired_before(__VA_ARGS__)))
135 #define OVS_ACQ_AFTER(...) __attribute__((acquired_after(__VA_ARGS__)))
136 #define OVS_NO_THREAD_SAFETY_ANALYSIS \
137     __attribute__((no_thread_safety_analysis))
138 #else  /* not Clang */
139 #define OVS_LOCKABLE
140 #define OVS_REQ_RDLOCK(...)
141 #define OVS_ACQ_RDLOCK(...)
142 #define OVS_REQ_WRLOCK(...)
143 #define OVS_ACQ_WRLOCK(...)
144 #define OVS_REQUIRES(...)
145 #define OVS_ACQUIRES(...)
146 #define OVS_TRY_WRLOCK(...)
147 #define OVS_TRY_RDLOCK(...)
148 #define OVS_TRY_LOCK(...)
149 #define OVS_GUARDED
150 #define OVS_GUARDED_BY(...)
151 #define OVS_EXCLUDED(...)
152 #define OVS_RELEASES(...)
153 #define OVS_ACQ_BEFORE(...)
154 #define OVS_ACQ_AFTER(...)
155 #define OVS_NO_THREAD_SAFETY_ANALYSIS
156 #endif
157
158 /* ISO C says that a C implementation may choose any integer type for an enum
159  * that is sufficient to hold all of its values.  Common ABIs (such as the
160  * System V ABI used on i386 GNU/Linux) always use a full-sized "int", even
161  * when a smaller type would suffice.
162  *
163  * In GNU C, "enum __attribute__((packed)) name { ... }" defines 'name' as an
164  * enum compatible with a type that is no bigger than necessary.  This is the
165  * intended use of OVS_PACKED_ENUM.
166  *
167  * OVS_PACKED_ENUM is intended for use only as a space optimization, since it
168  * only works with GCC.  That means that it must not be used in wire protocols
169  * or otherwise exposed outside of a single process. */
170 #if __GNUC__ && !__CHECKER__
171 #define OVS_PACKED_ENUM __attribute__((__packed__))
172 #else
173 #define OVS_PACKED_ENUM
174 #endif
175
176 #ifndef _MSC_VER
177 #define OVS_PACKED(DECL) DECL __attribute__((__packed__))
178 #else
179 #define OVS_PACKED(DECL) __pragma(pack(push, 1)) DECL __pragma(pack(pop))
180 #endif
181
182 /* For defining a structure whose instances should aligned on an N-byte
183  * boundary.
184  *
185  * e.g. The following:
186  *     OVS_ALIGNED_STRUCT(64, mystruct) { ... };
187  * is equivalent to the following except that it specifies 64-byte alignment:
188  *     struct mystruct { ... };
189  */
190 #ifndef _MSC_VER
191 #define OVS_ALIGNED_STRUCT(N, TAG) struct __attribute__((aligned(N))) TAG
192 #else
193 #define OVS_ALIGNED_STRUCT(N, TAG) __declspec(align(N)) struct TAG
194 #endif
195
196 #ifdef _MSC_VER
197 #define CCALL __cdecl
198 #pragma section(".CRT$XCU",read)
199 #define OVS_CONSTRUCTOR(f) \
200     static void __cdecl f(void); \
201     __declspec(allocate(".CRT$XCU")) void (__cdecl*f##_)(void) = f; \
202     static void __cdecl f(void)
203 #else
204 #define OVS_CONSTRUCTOR(f) \
205     static void f(void) __attribute__((constructor)); \
206     static void f(void)
207 #endif
208
209 #endif /* compiler.h */