attributes.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2024, 2026 Edward Kmett <ekmett@gmail.com>
// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0
#pragma once

 
#ifdef __cplusplus


 
#ifdef __has_attribute
  #define native_has_attribute(x) __has_attribute(x)
#else
  #define native_has_attribute(__x) 0
#endif

#if native_has_attribute(diagnose_if)
  #define native_diagnose_if(condition,message) \
    _Pragma("clang diagnostic push") \
    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
    __attribute__((diagnose_if(condition,message,"error"))) \
    _Pragma("clang diagnostic pop")
#else
  #define native_diagnose_if(condition,message)
#endif

 
#if defined(_MSC_VER)
  #define native_has_declspec_attribute(__x) 1
#elif defined(NATIVE_USE_DECLSPEC) && defined(__has_declspec_attribute)
  #define native_has_declspec_attribute(x) __has_declspec_attribute(x)
#else
  #define native_has_declspec_attribute(__x) 0
#endif
 
// MS ABI otherwise allocates space for a second empty accessor base.
#if native_has_declspec_attribute(empty_bases)
  #define native_empty_bases __declspec(empty_bases)
#else
  #define native_empty_bases
#endif


 
#if native_has_attribute(const)
  #define native_const __attribute__((const))
#else
  #define native_const
#endif

 
#if native_has_attribute(pure)
  #define native_pure __attribute__((pure))
#else
  #define native_pure
#endif



 
#if native_has_attribute(lifetimebound)
  #define native_lifetimebound [[clang::lifetimebound]]
#else
  #define native_lifetimebound
#endif

 
#if native_has_attribute(noescape)
  #define native_noescape __attribute__((noescape))
#else
  #define native_noescape
#endif

 
#define native_nodiscard [[nodiscard]]

 


 
#if native_has_attribute(always_inline)
  #define native_inline inline __attribute__((always_inline))
#elif defined _WIN32
  #define native_inline __forceinline
#else
  #define native_inline inline
#endif
 

 
#if native_has_attribute(flatten)
  #define native_flatten __attribute__((flatten))
#else
  #define native_flatten
#endif

 
#if native_has_attribute(artificial)
  #define native_artificial __attribute__((artificial))
#elif native_has_attribute(__artificial__)
  #define native_artificial __attribute__((__artificial__))
#else
  #define native_artificial
  #warning "[[artificial]] is not supported"
#endif

 
#if native_has_attribute(noinline)
  #define native_noinline __attribute__((noinline))
#else
  #define native_noinline
#endif

 
#if native_has_attribute(optnone)
  #define native_optnone __attribute__((optnone))
#else
  #define native_optnone
#endif


 
#if native_has_attribute(weak)
  #define native_weak __attribute__((weak))
#else
  #define native_weak
#endif

 
#if native_has_attribute(internal_linkage)
  #define native_internal_linkage __attribute__((internal_linkage))
#else
  #define native_internal_linkage
#endif

 
#if __has_cpp_attribute(clang::preferred_name)
  #define native_preferred_name(x) [[clang::preferred_name(__x)]]
#else
  #define native_preferred_name(__x)
#endif


 
#if native_has_attribute(__visibility__)
  #define native_visibility(...) __attribute__((__visibility__(__VA_ARGS__)))
#else
  #define native_visibility(...)
  #warning "[[visibility]] is not supported"
#endif

 
#if native_has_attribute(exclude_from_explicit_instantiation)
  #define native_exclude_from_explicit_instantiation __attribute__((exclude_from_explicit_instantiation))
#else
  #define native_exclude_from_explicit_instantiation
  #warning "[[exclude_from_explicit_instantiation]] is not supported"
#endif

 
#define native_hidden native_visibility("hidden") native_exclude_from_explicit_instantiation



 
#if __cpp_constinit
  #define native_constinit constinit
#elif native_has_attribute(require_constant_initialization)
  #define native_constinit __attribute__((require_constant_initialization))
#else
  #define native_constinit
#endif

 
#if native_has_attribute(uninitialized)
  #define native_uninitialized __attribute__((uninitialized))
#else
  #define native_uninitialized
#endif

 
#if __has_cpp_attribute(clang::reinitializes)
  #define native_reinitializes [[clang::reinitializes]]
#else
  #define native_reinitializes
#endif



 
#define native_target(x) __attribute__((target(x)))

 
#define native_target_clones(...) __attribute__((target_clones(_VA_ARGS_)))



 
#if native_has_attribute(hot)
  #define native_hot __attribute__((hot))
#else
  #define native_hot
#endif

 
#if native_has_attribute(cold)
  #define native_cold __attribute__((cold))
#else
  #define native_cold
#endif



 
#if native_has_attribute(consumable)
  #define native_consumable(__x) __attribute__((consumable(__x)))
#else
  #define native_consumable(__x)
#endif

 
#if native_has_attribute(callable_when)
  #define native_callable_when(...) __attribute__((callable_when(__VA_ARGS__)))
#else
  #define native_callable_when(...)
#endif

 
#if native_has_attribute(param_typestate)
  #define native_param_typestate(...) __attribute__((param_typestate(__VA_ARGS__)))
#else
  #define native_param_typestate(...)
#endif

 
#if native_has_attribute(return_typestate)
  #define native_return_typestate(...) __attribute__((return_typestate(__VA_ARGS__)))
#else
  #define native_return_typestate(...)
#endif

 
#define native_moving native_return_typestate("consumed") native_param_typestate("unconsumed")

 
#if native_has_attribute(set_typestate)
  #define native_set_typestate(...) __attribute__((set_typestate(__VA_ARGS__)))
#else
  #define native_set_typestate(...)
#endif

 
#if native_has_attribute(test_typestate)
  #define native_test_typestate(...) __attribute__((test_typestate(__VA_ARGS__)))
#else
  #define native_test_typestate
  #define native_test_typestate(...)
#endif // native_has_attribute(test_typestate)



 
#if native_has_attribute(no_thread_safety_analysis)
  #define native_no_thread_safety_analysis __attribute__((no_thread_safety_analysis))
#else
  #define native_no_thread_safety_analysis
#endif

 
#if native_has_attribute(lockable)
  #define native_lockable __attribute__((lockable))
#else
  #define native_lockable
#endif

 
#if native_has_attribute(scoped_lockable)
  #define native_scoped_lockable __attribute__((scoped_lockable))
#else
  #define native_scoped_lockable
#endif

 
#if native_has_attribute(guarded_var)
  #define native_guarded_var __attribute__((guarded_var))
#else
  #define native_guarded_var
#endif

 
#if native_has_attribute(pt_guarded_var)
  #define native_pt_guarded_var __attribute__((pt_guarded_var))
#else
  #define native_pt_guarded_var
#endif

 
#if native_has_attribute(guarded_by)
  #define native_guarded_by(x) __attribute__((guarded_by(x)))
#else
  #define native_guarded_by(x)
#endif

 
#if native_has_attribute(pt_guarded_by)
  #define native_pt_guarded_by(x) __attribute__((pt_guarded_by(x)))
#else
  #define native_pt_guarded_by(x)
#endif

 
#if native_has_attribute(acquired_before)
  #define native_acquired_before(...) __attribute__((acquired_before(__VA_ARGS__)))
#else
  #define native_acquired_before(...)
#endif

 
#if native_has_attribute(acquired_after)
  #define native_acquired_after(...) __attribute__((acquired_after(__VA_ARGS__)))
#else
  #define native_acquired_after(...)
#endif

 
#if native_has_attribute(exclusive_lock_function)
  #define native_exclusive_lock_function(...) __attribute__((exclusive_lock_function(__VA_ARGS__)))
#else
  #define native_exclusive_lock_function(...)
#endif

 
#if native_has_attribute(shared_trylock_function)
  #define native_shared_trylock_function(...) __attribute__((shared_trylock_function(__VA_ARGS__)))
#else
  #define native_shared_trylock_function(...)
#endif

 
#if native_has_attribute(unlock_function)
  #define native_unlock_function(...) __attribute__((unlock_function(__VA_ARGS__)))
#else
  #define native_unlock_function(...)
#endif

 
#if native_has_attribute(lock_returned)
  #define native_lock_returned(__x) __attribute__((lock_returned(__x)))
#else
  #define native_lock_returned(__x)
#endif

 
#if native_has_attribute(locks_excluded)
  #define native_locks_excluded(...) __attribute__((locks_excluded(__VA_ARGS__)))
#else
  #define native_locks_excluded(...)
#endif

 
#if native_has_attribute(exclusive_locks_required)
  #define native_exclusive_locks_required(...) __attribute__((exclusive_locks_required(__VA_ARGS__)))
#else
  #define native_exclusive_locks_required(...)
#endif

 
#if native_has_attribute(shared_locks_required)
  #define native_shared_locks_required(...) __attribute__((shared_locks_required(__VA_ARGS__)))
#else
  #define native_shared_locks_required(...)
#endif


 

 
#if __has_cpp_attribute(acquire_handle)
  #define native_acquire_handle(__x) [[clang::acquire_handle(__x)]]
#else
  #define native_acquire_handle(__x)
#endif

 
#if __has_cpp_attribute(release_handle)
  #define native_release_handle(__x) [[clang::release_handle(__x)]]
#else
  #define native_release_handle(__x)
#endif

 
#if __has_cpp_attribute(use_handle)
  #define native_use_handle(__x) [[clang::use_handle(__x)]]
#else
  #define native_use_handle(__x)
#endif



#if native_has_attribute(aligned)
  #define native_align(x) __attribute__((aligned(x)))
#else
  #define native_align(x)
#endif

 
#if native_has_attribute(assume_aligned)
  #define native_assume_aligned(x) __attribute__((assume_aligned(x)))
#else
  #define native_assume_aligned(x)
#endif

 
#if native_has_attribute(align_value)
  #define native_align_value(x) __attribute__((align_value(x)))
#else
  #define native_align_value(x)
#endif



 
#if native_has_attribute(malloc)
  #define native_malloc __attribute__((malloc))
#else
  #define native_malloc
#endif

 
#if native_has_attribute(alloc_align)
  #define native_alloc_align(N) __attribute__((alloc_align(N)))
#else
  #define native_alloc_align(__N)
#endif

 
#if native_has_attribute(alloc_size)
  #define native_alloc_size(N) __attribute__((alloc_size(N)))
#else
  #define native_alloc_size(__N)
#endif



 
#if native_has_attribute(null_terminated_string_arg)
  #define native_null_terminated_string_arg(x) __attribute__((null_terminated_string_arg(x)))
#else
  #define native_null_terminated_string_arg(x)
#endif



 
#if native_has_attribute(callback)
  #define native_callback(...) __attribute__((callback(__VA_ARGS__)))
#else
  #define native_callback(...)
#endif

 
#if native_has_attribute(noreturn)
#define native_noreturn __attribute__((noreturn))
#else
#define native_noreturn
#endif



 
#if native_has_attribute(returns_nonnull)
  #define native_returns_nonnull __attribute__((returns_nonnull))
#else
  #define native_returns_nonnull
#endif

 
#if native_has_attribute(nonnull)
  #define native_nonnull(...) __attribute__((nonnull(__VA_ARGS__)))
#else
  #define native_nonnull(...)
#endif

 
#ifdef __clang__
#define native_Nonnull _Nonnull
#define native_Nullable _Nullable
#define native_Null_unspecified _Null_unspecified
#else
#define native_Nonnull
#define native_Nullable
#define native_Null_unspecified
#endif



 
#ifdef __CUDACC__
#define native_host __host__
#define native_device __device__
#define native_global __global__
#else
#define native_host
#define native_device
#define native_global
#endif
 
#define native_hd native_host native_device



 
#if native_has_attribute(nonblocking)
  #define native_nonblocking [[clang::nonblocking]]
  #define native_blocking [[clang::blocking]]
  #define native_nonallocating [[clang::nonallocating]]
  #define native_allocating [[clang::allocating]]
  #define native_noalloc(x) [[clang::nonallocating(x)]]
  #define native_noblock(x) [[clang::nonblocking(x)]]
#else
  #define native_nonblocking
  #define native_blocking
  #define native_nonallocating
  #define native_allocating
  #define native_noalloc(__x)
  #define native_noblock(__x)
#endif

 
#define native_constexpr constexpr
 
#else
// The shared shader declarations carry no host compiler promises.
#define native_nodiscard
#define native_constexpr
#define native_inline inline
#define native_pure
#define native_const
#define native_lifetimebound
#define native_noescape
#define native_reinitializes
#define native_artificial
#define native_flatten
#endif