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// Declare a friend relationship in a class with a test. Used rather that FRIEND_TEST to avoid 45// globally importing gtest/gtest.h into the main ART header files. 46#define ART_FRIEND_TEST(test_set_name, individual_test)\ 47friend class test_set_name##_##individual_test##_Test 48 49// Declare a friend relationship in a class with a typed test. 50#define ART_FRIEND_TYPED_TEST(test_set_name, individual_test)\ 51template<typename T> ART_FRIEND_TEST(test_set_name, individual_test) 52 53// DISALLOW_COPY_AND_ASSIGN disallows the copy and operator= functions. It goes in the private: 54// declarations in a class. 55#if !defined(DISALLOW_COPY_AND_ASSIGN) 56#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ 57 TypeName(const TypeName&) = delete; \ 58 void operator=(const TypeName&) = delete 59#endif 60 61// A macro to disallow all the implicit constructors, namely the default constructor, copy 62// constructor and operator= functions. 63// 64// This should be used in the private: declarations for a class that wants to prevent anyone from 65// instantiating it. This is especially useful for classes containing only static methods. 66#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ 67 TypeName() = delete; \ 68 DISALLOW_COPY_AND_ASSIGN(TypeName) 69 70// A macro to disallow new and delete operators for a class. It goes in the private: declarations. 71// NOTE: Providing placement new (and matching delete) for constructing container elements. 72#define DISALLOW_ALLOCATION() \ 73 public: \ 74 NO_RETURN ALWAYS_INLINE void operator delete(void*, size_t) { UNREACHABLE(); } \ 75 ALWAYS_INLINE void* operator new(size_t, void* ptr) noexcept { return ptr; } \ 76 ALWAYS_INLINE void operator delete(void*, void*) noexcept { } \ 77 private: \ 78 void* operator new(size_t) = delete 79 80// The arraysize(arr) macro returns the # of elements in an array arr. 81// The expression is a compile-time constant, and therefore can be 82// used in defining new arrays, for example. If you use arraysize on 83// a pointer by mistake, you will get a compile-time error. 84// 85// One caveat is that arraysize() doesn't accept any array of an 86// anonymous type or a type defined inside a function. In these rare 87// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below. This is 88// due to a limitation in C++'s template system. The limitation might 89// eventually be removed, but it hasn't happened yet. 90 91// This template function declaration is used in defining arraysize. 92// Note that the function doesn't need an implementation, as we only 93// use its type. 94template <typename T, size_t N> 95char (&ArraySizeHelper(T (&array)[N]))[N]; 96 97#define arraysize(array) (sizeof(ArraySizeHelper(array))) 98 99// ARRAYSIZE_UNSAFE performs essentially the same calculation as arraysize, 100// but can be used on anonymous types or types defined inside 101// functions. It's less safe than arraysize as it accepts some 102// (although not all) pointers. Therefore, you should use arraysize 103// whenever possible. 104// 105// The expression ARRAYSIZE_UNSAFE(a) is a compile-time constant of type 106// size_t. 107// 108// ARRAYSIZE_UNSAFE catches a few type errors. If you see a compiler error 109// 110// "warning: division by zero in ..." 111// 112// when using ARRAYSIZE_UNSAFE, you are (wrongfully) giving it a pointer. 113// You should only use ARRAYSIZE_UNSAFE on statically allocated arrays. 114// 115// The following comments are on the implementation details, and can 116// be ignored by the users. 117// 118// ARRAYSIZE_UNSAFE(arr) works by inspecting sizeof(arr) (the # of bytes in 119// the array) and sizeof(*(arr)) (the # of bytes in one array 120// element). If the former is divisible by the latter, perhaps arr is 121// indeed an array, in which case the division result is the # of 122// elements in the array. Otherwise, arr cannot possibly be an array, 123// and we generate a compiler error to prevent the code from 124// compiling. 125// 126// Since the size of bool is implementation-defined, we need to cast 127// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final 128// result has type size_t. 129// 130// This macro is not perfect as it wrongfully accepts certain 131// pointers, namely where the pointer size is divisible by the pointee 132// size. Since all our code has to go through a 32-bit compiler, 133// where a pointer is 4 bytes, this means all pointers to a type whose 134// size is 3 or greater than 4 will be (righteously) rejected. 135#define ARRAYSIZE_UNSAFE(a) \ 136 ((sizeof(a) / sizeof(*(a))) / static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) 137 138#define SIZEOF_MEMBER(t, f) sizeof((reinterpret_cast<t*>(4096))->f) 139 140#define OFFSETOF_MEMBER(t, f) \ 141 (reinterpret_cast<uintptr_t>(&reinterpret_cast<t*>(16)->f) - static_cast<uintptr_t>(16u)) // NOLINT 142 143#define OFFSETOF_MEMBERPTR(t, f) \ 144 (reinterpret_cast<uintptr_t>(&(reinterpret_cast<t*>(16)->*f)) - static_cast<uintptr_t>(16)) // NOLINT 145 146#define PACKED(x) __attribute__ ((__aligned__(x), __packed__)) 147 148#define LIKELY(x) __builtin_expect((x), true) 149#define UNLIKELY(x) __builtin_expect((x), false) 150 151// Stringify the argument. 152#define QUOTE(x) #x 153#define STRINGIFY(x) QUOTE(x) 154 155#ifndef NDEBUG 156#define ALWAYS_INLINE 157#else 158#define ALWAYS_INLINE __attribute__ ((always_inline)) 159#endif 160 161#ifdef __clang__ 162/* clang doesn't like attributes on lambda functions */ 163#define ALWAYS_INLINE_LAMBDA 164#else 165#define ALWAYS_INLINE_LAMBDA ALWAYS_INLINE 166#endif 167 168#define NO_INLINE __attribute__ ((noinline)) 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 181// A deprecated function to call to create a false use of the parameter, for example: 182// int foo(int x) { UNUSED(x); return 10; } 183// to avoid compiler warnings. Going forward we prefer ATTRIBUTE_UNUSED. 184template<typename... T> void UNUSED(const T&...) {} 185 186// An attribute to place on a parameter to a function, for example: 187// int foo(int x ATTRIBUTE_UNUSED) { return 10; } 188// to avoid compiler warnings. 189#define ATTRIBUTE_UNUSED __attribute__((__unused__)) 190 191// Define that a position within code is unreachable, for example: 192// int foo () { LOG(FATAL) << "Don't call me"; UNREACHABLE(); } 193// without the UNREACHABLE a return statement would be necessary. 194#define UNREACHABLE __builtin_unreachable 195 196// Add the C++11 noreturn attribute. 197#define NO_RETURN [[ noreturn ]] // NOLINT[whitespace/braces] [5] 198 199// The FALLTHROUGH_INTENDED macro can be used to annotate implicit fall-through 200// between switch labels: 201// switch (x) { 202// case 40: 203// case 41: 204// if (truth_is_out_there) { 205// ++x; 206// FALLTHROUGH_INTENDED; // Use instead of/along with annotations in 207// // comments. 208// } else { 209// return x; 210// } 211// case 42: 212// ... 213// 214// As shown in the example above, the FALLTHROUGH_INTENDED macro should be 215// followed by a semicolon. It is designed to mimic control-flow statements 216// like 'break;', so it can be placed in most places where 'break;' can, but 217// only if there are no statements on the execution path between it and the 218// next switch label. 219// 220// When compiled with clang in C++11 mode, the FALLTHROUGH_INTENDED macro is 221// expanded to [[clang::fallthrough]] attribute, which is analysed when 222// performing switch labels fall-through diagnostic ('-Wimplicit-fallthrough'). 223// See clang documentation on language extensions for details: 224// http://clang.llvm.org/docs/LanguageExtensions.html#clang__fallthrough 225// 226// When used with unsupported compilers, the FALLTHROUGH_INTENDED macro has no 227// effect on diagnostics. 228// 229// In either case this macro has no effect on runtime behavior and performance 230// of code. 231#if defined(__clang__) && __cplusplus >= 201103L && defined(__has_warning) 232#if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough") 233#define FALLTHROUGH_INTENDED [[clang::fallthrough]] // NOLINT 234#endif 235#endif 236 237#ifndef FALLTHROUGH_INTENDED 238#define FALLTHROUGH_INTENDED do { } while (0) 239#endif 240 241// Annotalysis thread-safety analysis support. 242#if defined(__SUPPORT_TS_ANNOTATION__) || defined(__clang__) 243#define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x)) 244#else 245#define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op 246#endif 247 248#define ACQUIRED_AFTER(...) THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__)) 249#define ACQUIRED_BEFORE(...) THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__)) 250#define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x)) 251#define GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(guarded) 252#define LOCK_RETURNED(x) THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x)) 253#define NO_THREAD_SAFETY_ANALYSIS THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis) 254#define PT_GUARDED_BY(x) 255// THREAD_ANNOTATION_ATTRIBUTE__(point_to_guarded_by(x)) 256#define PT_GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(point_to_guarded) 257#define SCOPED_LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable) 258 259#if defined(__clang__) 260#define EXCLUSIVE_LOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__)) 261#define EXCLUSIVE_TRYLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__)) 262#define SHARED_LOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__)) 263#define SHARED_TRYLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__)) 264#define UNLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__)) 265#define REQUIRES(...) THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__)) 266#define SHARED_REQUIRES(...) THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__)) 267#define CAPABILITY(...) THREAD_ANNOTATION_ATTRIBUTE__(capability(__VA_ARGS__)) 268#define SHARED_CAPABILITY(...) THREAD_ANNOTATION_ATTRIBUTE__(shared_capability(__VA_ARGS__)) 269#define ASSERT_CAPABILITY(...) THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(__VA_ARGS__)) 270#define ASSERT_SHARED_CAPABILITY(...) THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(__VA_ARGS__)) 271#define RETURN_CAPABILITY(...) THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(__VA_ARGS__)) 272#define TRY_ACQUIRE(...) THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__)) 273#define TRY_ACQUIRE_SHARED(...) THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__)) 274#define ACQUIRE(...) THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__)) 275#define ACQUIRE_SHARED(...) THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__)) 276#define RELEASE(...) THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__)) 277#define RELEASE_SHARED(...) THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__)) 278#define SCOPED_CAPABILITY THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable) 279#else 280#define EXCLUSIVE_LOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock(__VA_ARGS__)) 281#define EXCLUSIVE_TRYLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock(__VA_ARGS__)) 282#define SHARED_LOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(shared_lock(__VA_ARGS__)) 283#define SHARED_TRYLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock(__VA_ARGS__)) 284#define UNLOCK_FUNCTION(...) THREAD_ANNOTATION_ATTRIBUTE__(unlock(__VA_ARGS__)) 285#define REQUIRES(...) 286#define SHARED_REQUIRES(...) 287#define CAPABILITY(...) 288#define SHARED_CAPABILITY(...) 289#define ASSERT_CAPABILITY(...) 290#define ASSERT_SHARED_CAPABILITY(...) 291#define RETURN_CAPABILITY(...) 292#define TRY_ACQUIRE(...) 293#define TRY_ACQUIRE_SHARED(...) 294#define ACQUIRE(...) 295#define ACQUIRE_SHARED(...) 296#define RELEASE(...) 297#define RELEASE_SHARED(...) 298#define SCOPED_CAPABILITY 299#endif 300 301#define LOCKABLE CAPABILITY("mutex") 302#define SHARED_LOCKABLE SHARED_CAPABILITY("mutex") 303 304#endif // ART_RUNTIME_BASE_MACROS_H_ 305