1 /*
2 * Copyright (C) 2010 The Android Open Source Project
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 ART_RUNTIME_BASE_MACROS_H_
18 #define ART_RUNTIME_BASE_MACROS_H_
19
20 #include <stddef.h> // for size_t
21 #include <unistd.h> // for TEMP_FAILURE_RETRY
22
23 // bionic and glibc both have TEMP_FAILURE_RETRY, but eg Mac OS' libc doesn't.
24 #ifndef TEMP_FAILURE_RETRY
25 #define TEMP_FAILURE_RETRY(exp) ({ \
26 decltype(exp) _rc; \
27 do { \
28 _rc = (exp); \
29 } while (_rc == -1 && errno == EINTR); \
30 _rc; })
31 #endif
32
33 #define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
34
35 // C++11 final and override keywords that were introduced in GCC version 4.7.
36 #if defined(__clang__) || GCC_VERSION >= 40700
37 #define OVERRIDE override
38 #define FINAL final
39 #else
40 #define OVERRIDE
41 #define FINAL
42 #endif
43
44 // The COMPILE_ASSERT macro can be used to verify that a compile time
45 // expression is true. For example, you could use it to verify the
46 // size of a static array:
47 //
48 // COMPILE_ASSERT(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES,
49 // content_type_names_incorrect_size);
50 //
51 // or to make sure a struct is smaller than a certain size:
52 //
53 // COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
54 //
55 // The second argument to the macro is the name of the variable. If
56 // the expression is false, most compilers will issue a warning/error
57 // containing the name of the variable.
58
59 template <bool>
60 struct CompileAssert {
61 };
62
63 #define COMPILE_ASSERT(expr, msg) \
64 typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] // NOLINT
65
66 // DISALLOW_COPY_AND_ASSIGN disallows the copy and operator= functions.
67 // It goes in the private: declarations in a class.
68 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
69 TypeName(const TypeName&); \
70 void operator=(const TypeName&)
71
72 // A macro to disallow all the implicit constructors, namely the
73 // default constructor, copy constructor and operator= functions.
74 //
75 // This should be used in the private: declarations for a class
76 // that wants to prevent anyone from instantiating it. This is
77 // especially useful for classes containing only static methods.
78 #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
79 TypeName(); \
80 DISALLOW_COPY_AND_ASSIGN(TypeName)
81
82 // The arraysize(arr) macro returns the # of elements in an array arr.
83 // The expression is a compile-time constant, and therefore can be
84 // used in defining new arrays, for example. If you use arraysize on
85 // a pointer by mistake, you will get a compile-time error.
86 //
87 // One caveat is that arraysize() doesn't accept any array of an
88 // anonymous type or a type defined inside a function. In these rare
89 // cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below. This is
90 // due to a limitation in C++'s template system. The limitation might
91 // eventually be removed, but it hasn't happened yet.
92
93 // This template function declaration is used in defining arraysize.
94 // Note that the function doesn't need an implementation, as we only
95 // use its type.
96 template <typename T, size_t N>
97 char (&ArraySizeHelper(T (&array)[N]))[N];
98
99 #define arraysize(array) (sizeof(ArraySizeHelper(array)))
100
101 // ARRAYSIZE_UNSAFE performs essentially the same calculation as arraysize,
102 // but can be used on anonymous types or types defined inside
103 // functions. It's less safe than arraysize as it accepts some
104 // (although not all) pointers. Therefore, you should use arraysize
105 // whenever possible.
106 //
107 // The expression ARRAYSIZE_UNSAFE(a) is a compile-time constant of type
108 // size_t.
109 //
110 // ARRAYSIZE_UNSAFE catches a few type errors. If you see a compiler error
111 //
112 // "warning: division by zero in ..."
113 //
114 // when using ARRAYSIZE_UNSAFE, you are (wrongfully) giving it a pointer.
115 // You should only use ARRAYSIZE_UNSAFE on statically allocated arrays.
116 //
117 // The following comments are on the implementation details, and can
118 // be ignored by the users.
119 //
120 // ARRAYSIZE_UNSAFE(arr) works by inspecting sizeof(arr) (the # of bytes in
121 // the array) and sizeof(*(arr)) (the # of bytes in one array
122 // element). If the former is divisible by the latter, perhaps arr is
123 // indeed an array, in which case the division result is the # of
124 // elements in the array. Otherwise, arr cannot possibly be an array,
125 // and we generate a compiler error to prevent the code from
126 // compiling.
127 //
128 // Since the size of bool is implementation-defined, we need to cast
129 // !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
130 // result has type size_t.
131 //
132 // This macro is not perfect as it wrongfully accepts certain
133 // pointers, namely where the pointer size is divisible by the pointee
134 // size. Since all our code has to go through a 32-bit compiler,
135 // where a pointer is 4 bytes, this means all pointers to a type whose
136 // size is 3 or greater than 4 will be (righteously) rejected.
137 #define ARRAYSIZE_UNSAFE(a) \
138 ((sizeof(a) / sizeof(*(a))) / static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
139
140 #define SIZEOF_MEMBER(t, f) sizeof((reinterpret_cast<t*>(4096))->f)
141
142 #define OFFSETOF_MEMBER(t, f) \
143 (reinterpret_cast<const char*>(&reinterpret_cast<t*>(16)->f) - reinterpret_cast<const char*>(16)) // NOLINT
144
145 #define OFFSETOF_VOLATILE_MEMBER(t, f) \
146 (reinterpret_cast<volatile char*>(&reinterpret_cast<t*>(16)->f) - reinterpret_cast<volatile char*>(16)) // NOLINT
147
148 #define PACKED(x) __attribute__ ((__aligned__(x), __packed__))
149
150 #define LIKELY(x) __builtin_expect((x), true)
151 #define UNLIKELY(x) __builtin_expect((x), false)
152
153 // Stringify the argument.
154 #define QUOTE(x) #x
155 #define STRINGIFY(x) QUOTE(x)
156
157 #ifndef NDEBUG
158 #define ALWAYS_INLINE
159 #else
160 #define ALWAYS_INLINE __attribute__ ((always_inline))
161 #endif
162
163 #ifdef __clang__
164 /* clang doesn't like attributes on lambda functions */
165 #define ALWAYS_INLINE_LAMBDA
166 #else
167 #define ALWAYS_INLINE_LAMBDA ALWAYS_INLINE
168 #endif
169
170 #if defined (__APPLE__)
171 #define HOT_ATTR
172 #define COLD_ATTR
173 #else
174 #define HOT_ATTR __attribute__ ((hot))
175 #define COLD_ATTR __attribute__ ((cold))
176 #endif
177
178 #define PURE __attribute__ ((__pure__))
179 #define WARN_UNUSED __attribute__((warn_unused_result))
180
UNUSED(const T &)181 template<typename T> void UNUSED(const T&) {}
182
183 // Annotalysis thread-safety analysis support.
184 #if defined(__SUPPORT_TS_ANNOTATION__) || defined(__clang__)
185 #define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
186 #else
187 #define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op
188 #endif
189
190 #define ACQUIRED_AFTER(...) THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
191 #define ACQUIRED_BEFORE(...) THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
192 #define EXCLUSIVE_LOCKS_REQUIRED(...) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
193 #define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
194 #define GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(guarded)
195 #define LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(lockable)
196 #define LOCK_RETURNED(x) THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
197 #define LOCKS_EXCLUDED(...) THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
198 #define NO_THREAD_SAFETY_ANALYSIS THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
199 #define PT_GUARDED_BY(x)
200 // THREAD_ANNOTATION_ATTRIBUTE__(point_to_guarded_by(x))
201 #define PT_GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(point_to_guarded)
202 #define SCOPED_LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
203 #define SHARED_LOCKS_REQUIRED(...) THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
204
205 #if defined(__clang__)
206 #define EXCLUSIVE_LOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
207 #define EXCLUSIVE_TRYLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
208 #define SHARED_LOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
209 #define SHARED_TRYLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
210 #define UNLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
211 #else
212 #define EXCLUSIVE_LOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock(__VA_ARGS__))
213 #define EXCLUSIVE_TRYLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock(__VA_ARGS__))
214 #define SHARED_LOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(shared_lock(__VA_ARGS__))
215 #define SHARED_TRYLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock(__VA_ARGS__))
216 #define UNLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(unlock(__VA_ARGS__))
217 #endif
218
219 #endif // ART_RUNTIME_BASE_MACROS_H_
220