golden hour

/usr/include/glib-2.0/glib

⬆️ Go Up

Upload

File/Folder	Size	Actions
deprecated	-	Del OK
galloca.h	3.82 KB	Del OK
garray.h	11.12 KB	Del OK
gasyncqueue.h	5.59 KB	Del OK
gatomic.h	26.57 KB	Del OK
gbacktrace.h	2.73 KB	Del OK
gbase64.h	2.27 KB	Del OK
gbitlock.h	2.83 KB	Del OK
gbookmarkfile.h	12.33 KB	Del OK
gbytes.h	3.26 KB	Del OK
gcharset.h	1.54 KB	Del OK
gchecksum.h	3.77 KB	Del OK
gconvert.h	5.78 KB	Del OK
gdataset.h	6.1 KB	Del OK
gdate.h	12.13 KB	Del OK
gdatetime.h	12.44 KB	Del OK
gdir.h	1.6 KB	Del OK
genviron.h	2.31 KB	Del OK
gerror.h	10.88 KB	Del OK
gfileutils.h	7.68 KB	Del OK
ggettext.h	2.37 KB	Del OK
ghash.h	7.7 KB	Del OK
ghmac.h	3.39 KB	Del OK
ghook.h	6.21 KB	Del OK
ghostutils.h	1.42 KB	Del OK
gi18n-lib.h	1.34 KB	Del OK
gi18n.h	1.14 KB	Del OK
giochannel.h	13.63 KB	Del OK
gkeyfile.h	14.56 KB	Del OK
glib-autocleanups.h	4.79 KB	Del OK
glist.h	6.77 KB	Del OK
gmacros.h	45.12 KB	Del OK
gmain.h	27.55 KB	Del OK
gmappedfile.h	1.94 KB	Del OK
gmarkup.h	10.62 KB	Del OK
gmem.h	14.51 KB	Del OK
gmessages.h	26.56 KB	Del OK
gnode.h	8.5 KB	Del OK
goption.h	15.72 KB	Del OK
gpattern.h	1.74 KB	Del OK
gpoll.h	4.03 KB	Del OK
gprimes.h	1.65 KB	Del OK
gprintf.h	1.94 KB	Del OK
gqsort.h	1.46 KB	Del OK
gquark.h	2.63 KB	Del OK
gqueue.h	7.57 KB	Del OK
grand.h	3.11 KB	Del OK
grcbox.h	3.9 KB	Del OK
grefcount.h	3.89 KB	Del OK
grefstring.h	1.82 KB	Del OK
gregex.h	27.44 KB	Del OK
gscanner.h	8.65 KB	Del OK
gsequence.h	8.6 KB	Del OK
gshell.h	1.71 KB	Del OK
gslice.h	4.48 KB	Del OK
gslist.h	6.4 KB	Del OK
gspawn.h	12.89 KB	Del OK
gstdio.h	4.99 KB	Del OK
gstrfuncs.h	13.14 KB	Del OK
gstring.h	8.14 KB	Del OK
gstringchunk.h	2.08 KB	Del OK
gstrvbuilder.h	1.58 KB	Del OK
gtestutils.h	34.31 KB	Del OK
gthread.h	18.32 KB	Del OK
gthreadpool.h	3.73 KB	Del OK
gtimer.h	2.52 KB	Del OK
gtimezone.h	3.81 KB	Del OK
gtrashstack.h	1.86 KB	Del OK
gtree.h	6.3 KB	Del OK
gtypes.h	20.04 KB	Del OK
gunicode.h	40.25 KB	Del OK
guri.h	16.06 KB	Del OK
gutils.h	14.22 KB	Del OK
guuid.h	1.26 KB	Del OK
gvariant.h	28.87 KB	Del OK
gvarianttype.h	12.93 KB	Del OK
gversion.h	1.93 KB	Del OK
gversionmacros.h	46.56 KB	Del OK
gwin32.h	4.56 KB	Del OK

Edit: gatomic.h

/* * Copyright © 2011 Ryan Lortie * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, see <http://www.gnu.org/licenses/>. * * Author: Ryan Lortie <desrt@desrt.ca> */ #ifndef __G_ATOMIC_H__ #define __G_ATOMIC_H__ #if !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION) #error "Only <glib.h> can be included directly." #endif #include <glib/gtypes.h> #if defined(glib_typeof_2_68) && GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_68 /* for glib_typeof */ #include <type_traits> #endif G_BEGIN_DECLS GLIB_AVAILABLE_IN_ALL gint g_atomic_int_get (const volatile gint *atomic); GLIB_AVAILABLE_IN_ALL void g_atomic_int_set (volatile gint *atomic, gint newval); GLIB_AVAILABLE_IN_ALL void g_atomic_int_inc (volatile gint *atomic); GLIB_AVAILABLE_IN_ALL gboolean g_atomic_int_dec_and_test (volatile gint *atomic); GLIB_AVAILABLE_IN_ALL gboolean g_atomic_int_compare_and_exchange (volatile gint *atomic, gint oldval, gint newval); GLIB_AVAILABLE_IN_ALL gint g_atomic_int_add (volatile gint *atomic, gint val); GLIB_AVAILABLE_IN_2_30 guint g_atomic_int_and (volatile guint *atomic, guint val); GLIB_AVAILABLE_IN_2_30 guint g_atomic_int_or (volatile guint *atomic, guint val); GLIB_AVAILABLE_IN_ALL guint g_atomic_int_xor (volatile guint *atomic, guint val); GLIB_AVAILABLE_IN_ALL gpointer g_atomic_pointer_get (const volatile void *atomic); GLIB_AVAILABLE_IN_ALL void g_atomic_pointer_set (volatile void *atomic, gpointer newval); GLIB_AVAILABLE_IN_ALL gboolean g_atomic_pointer_compare_and_exchange (volatile void *atomic, gpointer oldval, gpointer newval); GLIB_AVAILABLE_IN_ALL gssize g_atomic_pointer_add (volatile void *atomic, gssize val); GLIB_AVAILABLE_IN_2_30 gsize g_atomic_pointer_and (volatile void *atomic, gsize val); GLIB_AVAILABLE_IN_2_30 gsize g_atomic_pointer_or (volatile void *atomic, gsize val); GLIB_AVAILABLE_IN_ALL gsize g_atomic_pointer_xor (volatile void *atomic, gsize val); GLIB_DEPRECATED_IN_2_30_FOR(g_atomic_int_add) gint g_atomic_int_exchange_and_add (volatile gint *atomic, gint val); G_END_DECLS #if defined(G_ATOMIC_LOCK_FREE) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) /* We prefer the new C11-style atomic extension of GCC if available */ #if defined(__ATOMIC_SEQ_CST) #define g_atomic_int_get(atomic) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ gint gaig_temp; \ (void) (0 ? *(atomic) ^ *(atomic) : 1); \ __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ (gint) gaig_temp; \ })) #define g_atomic_int_set(atomic, newval) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ gint gais_temp = (gint) (newval); \ (void) (0 ? *(atomic) ^ (newval) : 1); \ __atomic_store ((gint *)(atomic), &gais_temp, __ATOMIC_SEQ_CST); \ })) #if defined(glib_typeof) && (!defined(glib_typeof_2_68) || GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_68) #define g_atomic_pointer_get(atomic) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ glib_typeof (*(atomic)) gapg_temp_newval; \ glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ gapg_temp_newval; \ })) #define g_atomic_pointer_set(atomic, newval) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ glib_typeof ((atomic)) gaps_temp_atomic = (atomic); \ glib_typeof (*(atomic)) gaps_temp_newval = (newval); \ (void) (0 ? (gpointer) * (atomic) : NULL); \ __atomic_store (gaps_temp_atomic, &gaps_temp_newval, __ATOMIC_SEQ_CST); \ })) #else /* if !(defined(glib_typeof) && (!defined(glib_typeof_2_68) || GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_68)) */ #define g_atomic_pointer_get(atomic) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ gpointer gapg_temp_newval; \ gpointer *gapg_temp_atomic = (gpointer *)(atomic); \ __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ gapg_temp_newval; \ })) #define g_atomic_pointer_set(atomic, newval) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ gpointer *gaps_temp_atomic = (gpointer *)(atomic); \ gpointer gaps_temp_newval = (gpointer)(newval); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ __atomic_store (gaps_temp_atomic, &gaps_temp_newval, __ATOMIC_SEQ_CST); \ })) #endif /* if defined(glib_typeof) && (!defined(glib_typeof_2_68) || GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_68) */ #define g_atomic_int_inc(atomic) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ *(atomic) : 1); \ (void) __atomic_fetch_add ((atomic), 1, __ATOMIC_SEQ_CST); \ })) #define g_atomic_int_dec_and_test(atomic) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ *(atomic) : 1); \ __atomic_fetch_sub ((atomic), 1, __ATOMIC_SEQ_CST) == 1; \ })) #define g_atomic_int_compare_and_exchange(atomic, oldval, newval) \ (G_GNUC_EXTENSION ({ \ gint gaicae_oldval = (oldval); \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); \ __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ })) #define g_atomic_int_add(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ (val) : 1); \ (gint) __atomic_fetch_add ((atomic), (val), __ATOMIC_SEQ_CST); \ })) #define g_atomic_int_and(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ (val) : 1); \ (guint) __atomic_fetch_and ((atomic), (val), __ATOMIC_SEQ_CST); \ })) #define g_atomic_int_or(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ (val) : 1); \ (guint) __atomic_fetch_or ((atomic), (val), __ATOMIC_SEQ_CST); \ })) #define g_atomic_int_xor(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ (val) : 1); \ (guint) __atomic_fetch_xor ((atomic), (val), __ATOMIC_SEQ_CST); \ })) #if defined(glib_typeof) && defined(__cplusplus) && __cplusplus >= 201103L /* This is typesafe because we check we can assign oldval to the type of * (*atomic). Unfortunately it can only be done in C++ because gcc/clang warn * when atomic is volatile and not oldval, or when atomic is gsize* and oldval * is NULL. Note that clang++ force us to be typesafe because it is an error if the 2nd * argument of __atomic_compare_exchange_n() has a different type than the * first. * https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1919 * https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1715#note_1024120. */ #define g_atomic_pointer_compare_and_exchange(atomic, oldval, newval) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof (oldval) == sizeof (gpointer)); \ glib_typeof (*(atomic)) gapcae_oldval = (oldval); \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ })) #else /* if !(defined(glib_typeof) && defined(__cplusplus) && __cplusplus >= 201103L) */ #define g_atomic_pointer_compare_and_exchange(atomic, oldval, newval) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof (oldval) == sizeof (gpointer)); \ gpointer gapcae_oldval = (gpointer)(oldval); \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ })) #endif /* defined(glib_typeof) */ #define g_atomic_pointer_add(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ (void) (0 ? (val) ^ (val) : 1); \ (gssize) __atomic_fetch_add ((atomic), (val), __ATOMIC_SEQ_CST); \ })) #define g_atomic_pointer_and(atomic, val) \ (G_GNUC_EXTENSION ({ \ gsize *gapa_atomic = (gsize *) (atomic); \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gsize)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ (void) (0 ? (val) ^ (val) : 1); \ (gsize) __atomic_fetch_and (gapa_atomic, (val), __ATOMIC_SEQ_CST); \ })) #define g_atomic_pointer_or(atomic, val) \ (G_GNUC_EXTENSION ({ \ gsize *gapo_atomic = (gsize *) (atomic); \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gsize)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ (void) (0 ? (val) ^ (val) : 1); \ (gsize) __atomic_fetch_or (gapo_atomic, (val), __ATOMIC_SEQ_CST); \ })) #define g_atomic_pointer_xor(atomic, val) \ (G_GNUC_EXTENSION ({ \ gsize *gapx_atomic = (gsize *) (atomic); \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gsize)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ (void) (0 ? (val) ^ (val) : 1); \ (gsize) __atomic_fetch_xor (gapx_atomic, (val), __ATOMIC_SEQ_CST); \ })) #else /* defined(__ATOMIC_SEQ_CST) */ /* We want to achieve __ATOMIC_SEQ_CST semantics here. See * https://en.cppreference.com/w/c/atomic/memory_order#Constants. For load * operations, that means performing an *acquire*: * > A load operation with this memory order performs the acquire operation on * > the affected memory location: no reads or writes in the current thread can * > be reordered before this load. All writes in other threads that release * > the same atomic variable are visible in the current thread. * * “no reads or writes in the current thread can be reordered before this load” * is implemented using a compiler barrier (a no-op `__asm__` section) to * prevent instruction reordering. Writes in other threads are synchronised * using `__sync_synchronize()`. It’s unclear from the GCC documentation whether * `__sync_synchronize()` acts as a compiler barrier, hence our explicit use of * one. * * For store operations, `__ATOMIC_SEQ_CST` means performing a *release*: * > A store operation with this memory order performs the release operation: * > no reads or writes in the current thread can be reordered after this store. * > All writes in the current thread are visible in other threads that acquire * > the same atomic variable (see Release-Acquire ordering below) and writes * > that carry a dependency into the atomic variable become visible in other * > threads that consume the same atomic (see Release-Consume ordering below). * * “no reads or writes in the current thread can be reordered after this store” * is implemented using a compiler barrier to prevent instruction reordering. * “All writes in the current thread are visible in other threads” is implemented * using `__sync_synchronize()`; similarly for “writes that carry a dependency”. */ #define g_atomic_int_get(atomic) \ (G_GNUC_EXTENSION ({ \ gint gaig_result; \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ *(atomic) : 1); \ gaig_result = (gint) *(atomic); \ __sync_synchronize (); \ __asm__ __volatile__ ("" : : : "memory"); \ gaig_result; \ })) #define g_atomic_int_set(atomic, newval) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ (newval) : 1); \ __sync_synchronize (); \ __asm__ __volatile__ ("" : : : "memory"); \ *(atomic) = (newval); \ })) #define g_atomic_pointer_get(atomic) \ (G_GNUC_EXTENSION ({ \ gpointer gapg_result; \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ gapg_result = (gpointer) *(atomic); \ __sync_synchronize (); \ __asm__ __volatile__ ("" : : : "memory"); \ gapg_result; \ })) #if defined(glib_typeof) && (!defined(glib_typeof_2_68) || GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_68) #define g_atomic_pointer_set(atomic, newval) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ __sync_synchronize (); \ __asm__ __volatile__ ("" : : : "memory"); \ *(atomic) = (glib_typeof (*(atomic))) (gsize) (newval); \ })) #else /* if !(defined(glib_typeof) && (!defined(glib_typeof_2_68) || GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_68)) */ #define g_atomic_pointer_set(atomic, newval) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ __sync_synchronize (); \ __asm__ __volatile__ ("" : : : "memory"); \ *(atomic) = (gpointer) (gsize) (newval); \ })) #endif /* if defined(glib_typeof) && (!defined(glib_typeof_2_68) || GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_68) */ #define g_atomic_int_inc(atomic) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ *(atomic) : 1); \ (void) __sync_fetch_and_add ((atomic), 1); \ })) #define g_atomic_int_dec_and_test(atomic) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ *(atomic) : 1); \ __sync_fetch_and_sub ((atomic), 1) == 1; \ })) #define g_atomic_int_compare_and_exchange(atomic, oldval, newval) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); \ __sync_bool_compare_and_swap ((atomic), (oldval), (newval)) ? TRUE : FALSE; \ })) #define g_atomic_int_add(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ (val) : 1); \ (gint) __sync_fetch_and_add ((atomic), (val)); \ })) #define g_atomic_int_and(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ (val) : 1); \ (guint) __sync_fetch_and_and ((atomic), (val)); \ })) #define g_atomic_int_or(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ (val) : 1); \ (guint) __sync_fetch_and_or ((atomic), (val)); \ })) #define g_atomic_int_xor(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ (void) (0 ? *(atomic) ^ (val) : 1); \ (guint) __sync_fetch_and_xor ((atomic), (val)); \ })) #define g_atomic_pointer_compare_and_exchange(atomic, oldval, newval) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ __sync_bool_compare_and_swap ((atomic), (oldval), (newval)) ? TRUE : FALSE; \ })) #define g_atomic_pointer_add(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ (void) (0 ? (val) ^ (val) : 1); \ (gssize) __sync_fetch_and_add ((atomic), (val)); \ })) #define g_atomic_pointer_and(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ (void) (0 ? (val) ^ (val) : 1); \ (gsize) __sync_fetch_and_and ((atomic), (val)); \ })) #define g_atomic_pointer_or(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ (void) (0 ? (val) ^ (val) : 1); \ (gsize) __sync_fetch_and_or ((atomic), (val)); \ })) #define g_atomic_pointer_xor(atomic, val) \ (G_GNUC_EXTENSION ({ \ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ (void) (0 ? (gpointer) *(atomic) : NULL); \ (void) (0 ? (val) ^ (val) : 1); \ (gsize) __sync_fetch_and_xor ((atomic), (val)); \ })) #endif /* !defined(__ATOMIC_SEQ_CST) */ #else /* defined(G_ATOMIC_LOCK_FREE) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) */ #define g_atomic_int_get(atomic) \ (g_atomic_int_get ((gint *) (atomic))) #define g_atomic_int_set(atomic, newval) \ (g_atomic_int_set ((gint *) (atomic), (gint) (newval))) #define g_atomic_int_compare_and_exchange(atomic, oldval, newval) \ (g_atomic_int_compare_and_exchange ((gint *) (atomic), (oldval), (newval))) #define g_atomic_int_add(atomic, val) \ (g_atomic_int_add ((gint *) (atomic), (val))) #define g_atomic_int_and(atomic, val) \ (g_atomic_int_and ((guint *) (atomic), (val))) #define g_atomic_int_or(atomic, val) \ (g_atomic_int_or ((guint *) (atomic), (val))) #define g_atomic_int_xor(atomic, val) \ (g_atomic_int_xor ((guint *) (atomic), (val))) #define g_atomic_int_inc(atomic) \ (g_atomic_int_inc ((gint *) (atomic))) #define g_atomic_int_dec_and_test(atomic) \ (g_atomic_int_dec_and_test ((gint *) (atomic))) #if defined(glib_typeof) && (!defined(glib_typeof_2_68) || GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_68) /* The (void *) cast in the middle *looks* redundant, because * g_atomic_pointer_get returns void * already, but it's to silence * -Werror=bad-function-cast when we're doing something like: * guintptr a, b; ...; a = g_atomic_pointer_get (&b); * which would otherwise be assigning the void * result of * g_atomic_pointer_get directly to the pointer-sized but * non-pointer-typed result. */ #define g_atomic_pointer_get(atomic) \ (glib_typeof (*(atomic))) (void *) ((g_atomic_pointer_get) ((void *) atomic)) #else /* !(defined(glib_typeof) && (!defined(glib_typeof_2_68) || GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_68)) */ #define g_atomic_pointer_get(atomic) \ (g_atomic_pointer_get (atomic)) #endif #define g_atomic_pointer_set(atomic, newval) \ (g_atomic_pointer_set ((atomic), (gpointer) (newval))) #define g_atomic_pointer_compare_and_exchange(atomic, oldval, newval) \ (g_atomic_pointer_compare_and_exchange ((atomic), (gpointer) (oldval), (gpointer) (newval))) #define g_atomic_pointer_add(atomic, val) \ (g_atomic_pointer_add ((atomic), (gssize) (val))) #define g_atomic_pointer_and(atomic, val) \ (g_atomic_pointer_and ((atomic), (gsize) (val))) #define g_atomic_pointer_or(atomic, val) \ (g_atomic_pointer_or ((atomic), (gsize) (val))) #define g_atomic_pointer_xor(atomic, val) \ (g_atomic_pointer_xor ((atomic), (gsize) (val))) #endif /* defined(G_ATOMIC_LOCK_FREE) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) */ #endif /* __G_ATOMIC_H__ */
Save