1 /* 2 * Copyright (c) 2008-2020 Apple Inc. All rights reserved. 3 * 4 * @APPLE_APACHE_LICENSE_HEADER_START@ 5 * 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 * 18 * @APPLE_APACHE_LICENSE_HEADER_END@ 19 */ 20 21 #ifndef __OS_BASE__ 22 #define __OS_BASE__ 23 24 #include <sys/cdefs.h> 25 26 27 #ifndef __has_builtin 28 #define __has_builtin(x) 0 29 #endif 30 #ifndef __has_include 31 #define __has_include(x) 0 32 #endif 33 #ifndef __has_feature 34 #define __has_feature(x) 0 35 #endif 36 #ifndef __has_attribute 37 #define __has_attribute(x) 0 38 #endif 39 #ifndef __has_extension 40 #define __has_extension(x) 0 41 #endif 42 43 #undef OS_INLINE // <sys/_types/_os_inline.h> 44 #if __GNUC__ 45 #define OS_NORETURN __attribute__((__noreturn__)) 46 #define OS_NOTHROW __attribute__((__nothrow__)) 47 #define OS_NONNULL1 __attribute__((__nonnull__(1))) 48 #define OS_NONNULL2 __attribute__((__nonnull__(2))) 49 #define OS_NONNULL3 __attribute__((__nonnull__(3))) 50 #define OS_NONNULL4 __attribute__((__nonnull__(4))) 51 #define OS_NONNULL5 __attribute__((__nonnull__(5))) 52 #define OS_NONNULL6 __attribute__((__nonnull__(6))) 53 #define OS_NONNULL7 __attribute__((__nonnull__(7))) 54 #define OS_NONNULL8 __attribute__((__nonnull__(8))) 55 #define OS_NONNULL9 __attribute__((__nonnull__(9))) 56 #define OS_NONNULL10 __attribute__((__nonnull__(10))) 57 #define OS_NONNULL11 __attribute__((__nonnull__(11))) 58 #define OS_NONNULL12 __attribute__((__nonnull__(12))) 59 #define OS_NONNULL13 __attribute__((__nonnull__(13))) 60 #define OS_NONNULL14 __attribute__((__nonnull__(14))) 61 #define OS_NONNULL15 __attribute__((__nonnull__(15))) 62 #define OS_NONNULL_ALL __attribute__((__nonnull__)) 63 #define OS_SENTINEL __attribute__((__sentinel__)) 64 #define OS_PURE __attribute__((__pure__)) 65 #define OS_CONST __attribute__((__const__)) 66 #define OS_WARN_RESULT __attribute__((__warn_unused_result__)) 67 #define OS_MALLOC __attribute__((__malloc__)) 68 #define OS_USED __attribute__((__used__)) 69 #define OS_UNUSED __attribute__((__unused__)) 70 #define OS_COLD __attribute__((__cold__)) 71 #define OS_WEAK __attribute__((__weak__)) 72 #define OS_WEAK_IMPORT __attribute__((__weak_import__)) 73 #define OS_NOINLINE __attribute__((__noinline__)) 74 #define OS_ALWAYS_INLINE __attribute__((__always_inline__)) 75 #define OS_TRANSPARENT_UNION __attribute__((__transparent_union__)) 76 #define OS_ALIGNED(n) __attribute__((__aligned__((n)))) 77 #define OS_FORMAT_PRINTF(x, y) __attribute__((__format__(printf,x,y))) 78 #define OS_EXPORT extern __attribute__((__visibility__("default"))) 79 #define OS_INLINE static __inline__ 80 #define OS_EXPECT(x, v) __builtin_expect((x), (v)) 81 #else 82 #define OS_NORETURN 83 #define OS_NOTHROW 84 #define OS_NONNULL1 85 #define OS_NONNULL2 86 #define OS_NONNULL3 87 #define OS_NONNULL4 88 #define OS_NONNULL5 89 #define OS_NONNULL6 90 #define OS_NONNULL7 91 #define OS_NONNULL8 92 #define OS_NONNULL9 93 #define OS_NONNULL10 94 #define OS_NONNULL11 95 #define OS_NONNULL12 96 #define OS_NONNULL13 97 #define OS_NONNULL14 98 #define OS_NONNULL15 99 #define OS_NONNULL_ALL 100 #define OS_SENTINEL 101 #define OS_PURE 102 #define OS_CONST 103 #define OS_WARN_RESULT 104 #define OS_MALLOC 105 #define OS_USED 106 #define OS_UNUSED 107 #define OS_COLD 108 #define OS_WEAK 109 #define OS_WEAK_IMPORT 110 #define OS_NOINLINE 111 #define OS_ALWAYS_INLINE 112 #define OS_TRANSPARENT_UNION 113 #define OS_ALIGNED(n) 114 #define OS_FORMAT_PRINTF(x, y) 115 #define OS_EXPORT extern 116 #define OS_INLINE static inline 117 #define OS_EXPECT(x, v) (x) 118 #endif 119 120 #if __has_attribute(noescape) 121 #define OS_NOESCAPE __attribute__((__noescape__)) 122 #else 123 #define OS_NOESCAPE 124 #endif 125 126 #if defined(__cplusplus) && defined(__clang__) 127 #define OS_FALLTHROUGH [[clang::fallthrough]] 128 #elif __has_attribute(fallthrough) 129 #define OS_FALLTHROUGH __attribute__((__fallthrough__)) 130 #else 131 #define OS_FALLTHROUGH 132 #endif 133 134 #if __has_feature(assume_nonnull) 135 #define OS_ASSUME_NONNULL_BEGIN _Pragma("clang assume_nonnull begin") 136 #define OS_ASSUME_NONNULL_END _Pragma("clang assume_nonnull end") 137 #else 138 #define OS_ASSUME_NONNULL_BEGIN 139 #define OS_ASSUME_NONNULL_END 140 #endif 141 142 #if __has_builtin(__builtin_assume) 143 #define OS_COMPILER_CAN_ASSUME(expr) __builtin_assume(expr) 144 #else 145 #define OS_COMPILER_CAN_ASSUME(expr) ((void)(expr)) 146 #endif 147 148 #if __has_extension(attribute_overloadable) 149 #define OS_OVERLOADABLE __attribute__((__overloadable__)) 150 #else 151 #define OS_OVERLOADABLE 152 #endif 153 154 #if __has_attribute(analyzer_suppress) 155 #define OS_ANALYZER_SUPPRESS(RADAR) __attribute__((analyzer_suppress)) 156 #else 157 #define OS_ANALYZER_SUPPRESS(RADAR) 158 #endif 159 160 #if __has_attribute(enum_extensibility) 161 #define __OS_ENUM_ATTR __attribute__((enum_extensibility(open))) 162 #define __OS_ENUM_ATTR_CLOSED __attribute__((enum_extensibility(closed))) 163 #else 164 #define __OS_ENUM_ATTR 165 #define __OS_ENUM_ATTR_CLOSED 166 #endif // __has_attribute(enum_extensibility) 167 168 #if __has_attribute(flag_enum) 169 /*! 170 * Compile with -Wflag-enum and -Wassign-enum to enforce at definition and 171 * assignment, respectively, i.e. -Wflag-enum prevents you from creating new 172 * enumeration values from illegal values within the enum definition, and 173 * -Wassign-enum prevents you from assigning illegal values to a variable of the 174 * enum type. 175 */ 176 #define __OS_OPTIONS_ATTR __attribute__((flag_enum)) 177 #else 178 #define __OS_OPTIONS_ATTR 179 #endif // __has_attribute(flag_enum) 180 181 #if __has_feature(objc_fixed_enum) || __has_extension(cxx_fixed_enum) || \ 182 __has_extension(cxx_strong_enums) 183 #define OS_ENUM(_name, _type, ...) \ 184 typedef enum : _type { __VA_ARGS__ } _name##_t 185 #define OS_CLOSED_ENUM(_name, _type, ...) \ 186 typedef enum : _type { __VA_ARGS__ } __OS_ENUM_ATTR_CLOSED _name##_t 187 #define OS_OPTIONS(_name, _type, ...) \ 188 typedef enum : _type { __VA_ARGS__ } __OS_ENUM_ATTR __OS_OPTIONS_ATTR _name##_t 189 #define OS_CLOSED_OPTIONS(_name, _type, ...) \ 190 typedef enum : _type { __VA_ARGS__ } __OS_ENUM_ATTR_CLOSED __OS_OPTIONS_ATTR _name##_t 191 #else 192 /*! 193 * There is unfortunately no good way in plain C to have both fixed-type enums 194 * and enforcement for clang's enum_extensibility extensions. The primary goal 195 * of these macros is to allow you to define an enum and specify its width in a 196 * single statement, and for plain C that is accomplished by defining an 197 * anonymous enum and then separately typedef'ing the requested type name to the 198 * requested underlying integer type. So the type emitted actually has no 199 * relationship at all to the enum, and therefore while the compiler could 200 * enforce enum extensibility if you used the enum type, it cannot do so if you 201 * use the "_t" type resulting from this expression. 202 * 203 * But we still define a named enum type and decorate it appropriately for you, 204 * so if you really want the enum extensibility enforcement, you can use the 205 * enum type yourself, i.e. when compiling with a C compiler: 206 * 207 * OS_CLOSED_ENUM(my_type, uint64_t, 208 * FOO, 209 * BAR, 210 * BAZ, 211 * ); 212 * 213 * my_type_t mt = 98; // legal 214 * enum my_type emt = 98; // illegal 215 * 216 * But be aware that the underlying enum type's width is subject only to the C 217 * language's guarantees -- namely that it will be compatible with int, char, 218 * and unsigned char. It is not safe to rely on the size of this type. 219 * 220 * When compiling in ObjC or C++, both of the above assignments are illegal. 221 */ 222 #define __OS_ENUM_C_FALLBACK(_name, _type, ...) \ 223 typedef _type _name##_t; enum _name { __VA_ARGS__ } 224 225 #define OS_ENUM(_name, _type, ...) \ 226 typedef _type _name##_t; enum { __VA_ARGS__ } 227 #define OS_CLOSED_ENUM(_name, _type, ...) \ 228 __OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \ 229 __OS_ENUM_ATTR_CLOSED 230 #define OS_OPTIONS(_name, _type, ...) \ 231 __OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \ 232 __OS_ENUM_ATTR __OS_OPTIONS_ATTR 233 #define OS_CLOSED_OPTIONS(_name, _type, ...) \ 234 __OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \ 235 __OS_ENUM_ATTR_CLOSED __OS_OPTIONS_ATTR 236 #endif // __has_feature(objc_fixed_enum) || __has_extension(cxx_strong_enums) 237 238 #if __has_feature(attribute_availability_swift) 239 // equivalent to __SWIFT_UNAVAILABLE from Availability.h 240 #define OS_SWIFT_UNAVAILABLE(_msg) \ 241 __attribute__((__availability__(swift, unavailable, message=_msg))) 242 #else 243 #define OS_SWIFT_UNAVAILABLE(_msg) 244 #endif 245 246 #if __has_attribute(__swift_attr__) 247 #define OS_SWIFT_UNAVAILABLE_FROM_ASYNC(msg) \ 248 __attribute__((__swift_attr__("@_unavailableFromAsync(message: \"" msg "\")"))) 249 #else 250 #define OS_SWIFT_UNAVAILABLE_FROM_ASYNC(msg) 251 #endif 252 253 #if __has_attribute(swift_private) 254 # define OS_REFINED_FOR_SWIFT __attribute__((__swift_private__)) 255 #else 256 # define OS_REFINED_FOR_SWIFT 257 #endif 258 259 #if __has_attribute(swift_name) 260 # define OS_SWIFT_NAME(_name) __attribute__((__swift_name__(#_name))) 261 #else 262 # define OS_SWIFT_NAME(_name) 263 #endif 264 265 #define __OS_STRINGIFY(s) #s 266 #define OS_STRINGIFY(s) __OS_STRINGIFY(s) 267 #define __OS_CONCAT(x, y) x ## y 268 #define OS_CONCAT(x, y) __OS_CONCAT(x, y) 269 270 #ifdef __GNUC__ 271 #define os_prevent_tail_call_optimization() __asm__("") 272 #define os_is_compile_time_constant(expr) __builtin_constant_p(expr) 273 #define os_compiler_barrier() __asm__ __volatile__("" ::: "memory") 274 #else 275 #define os_prevent_tail_call_optimization() do { } while (0) 276 #define os_is_compile_time_constant(expr) 0 277 #define os_compiler_barrier() do { } while (0) 278 #endif 279 280 #if __has_attribute(not_tail_called) 281 #define OS_NOT_TAIL_CALLED __attribute__((__not_tail_called__)) 282 #else 283 #define OS_NOT_TAIL_CALLED 284 #endif 285 286 #if KERNEL 287 /* 288 * LIBKERN_ALWAYS_DESTROY attribute can be applied to global variables with 289 * destructors. It specifies that and object should have its exit-time 290 * destructor run. This attribute is the default unless clang was invoked with 291 * -fno-c++-static-destructors. 292 */ 293 #if __has_attribute(always_destroy) 294 #define LIBKERN_ALWAYS_DESTROY __attribute__((__always_destroy__)) 295 #else 296 #define LIBKERN_ALWAYS_DESTROY 297 #endif 298 #endif 299 300 typedef void (*os_function_t)(void *_Nullable); 301 302 #ifdef __BLOCKS__ 303 /*! 304 * @typedef os_block_t 305 * 306 * @abstract 307 * Generic type for a block taking no arguments and returning no value. 308 * 309 * @discussion 310 * When not building with Objective-C ARC, a block object allocated on or 311 * copied to the heap must be released with a -[release] message or the 312 * Block_release() function. 313 * 314 * The declaration of a block literal allocates storage on the stack. 315 * Therefore, this is an invalid construct: 316 * <code> 317 * os_block_t block; 318 * if (x) { 319 * block = ^{ printf("true\n"); }; 320 * } else { 321 * block = ^{ printf("false\n"); }; 322 * } 323 * block(); // unsafe!!! 324 * </code> 325 * 326 * What is happening behind the scenes: 327 * <code> 328 * if (x) { 329 * struct Block __tmp_1 = ...; // setup details 330 * block = &__tmp_1; 331 * } else { 332 * struct Block __tmp_2 = ...; // setup details 333 * block = &__tmp_2; 334 * } 335 * </code> 336 * 337 * As the example demonstrates, the address of a stack variable is escaping the 338 * scope in which it is allocated. That is a classic C bug. 339 * 340 * Instead, the block literal must be copied to the heap with the Block_copy() 341 * function or by sending it a -[copy] message. 342 */ 343 typedef void (^os_block_t)(void); 344 #endif 345 346 #if KERNEL 347 #if __has_feature(ptrauth_calls) 348 #include <ptrauth.h> 349 #define OS_PTRAUTH_SIGNED_PTR(type) __ptrauth(ptrauth_key_process_independent_data, 1, ptrauth_string_discriminator(type)) 350 #define OS_PTRAUTH_SIGNED_PTR_AUTH_NULL(type) __ptrauth(ptrauth_key_process_independent_data, 1, ptrauth_string_discriminator(type), "authenticates-null-values") 351 #define OS_PTRAUTH_DISCRIMINATOR(str) ptrauth_string_discriminator(str) 352 #define __ptrauth_only 353 #else // __has_feature(ptrauth_calls) 354 #define OS_PTRAUTH_SIGNED_PTR(type) 355 #define OS_PTRAUTH_SIGNED_PTR_AUTH_NULL(type) 356 #define OS_PTRAUTH_DISCRIMINATOR(str) 0 357 #define __ptrauth_only __unused 358 #endif // __has_feature(ptrauth_calls) 359 #endif // KERNEL 360 361 #if KERNEL 362 #if __has_feature(ptrauth_calls) 363 #define XNU_PTRAUTH_SIGNED_FUNCTION_PTR(type) \ 364 __ptrauth(ptrauth_key_function_pointer, 1, ptrauth_string_discriminator(type)) 365 #else 366 #define XNU_PTRAUTH_SIGNED_FUNCTION_PTR(type) 367 #endif 368 #define XNU_PTRAUTH_SIGNED_PTR OS_PTRAUTH_SIGNED_PTR 369 #define XNU_PTRAUTH_SIGNED_PTR_AUTH_NULL OS_PTRAUTH_SIGNED_PTR_AUTH_NULL 370 #endif // KERNEL 371 372 #define OS_ASSUME_PTR_ABI_SINGLE_BEGIN __ASSUME_PTR_ABI_SINGLE_BEGIN 373 #define OS_ASSUME_PTR_ABI_SINGLE_END __ASSUME_PTR_ABI_SINGLE_END 374 #define OS_UNSAFE_INDEXABLE __unsafe_indexable 375 #define OS_HEADER_INDEXABLE __header_indexable 376 #define OS_COUNTED_BY(N) __counted_by(N) 377 #define OS_SIZED_BY(N) __sized_by(N) 378 379 #endif // __OS_BASE__ 380