atomic.h revision 254612
14887Schin/*- 24887Schin * Copyright (c) 1998 Doug Rabson 34887Schin * All rights reserved. 412068SRoger.Faulkner@Oracle.COM * 54887Schin * Redistribution and use in source and binary forms, with or without 64887Schin * modification, are permitted provided that the following conditions 78462SApril.Chin@Sun.COM * are met: 84887Schin * 1. Redistributions of source code must retain the above copyright 94887Schin * notice, this list of conditions and the following disclaimer. 104887Schin * 2. Redistributions in binary form must reproduce the above copyright 114887Schin * notice, this list of conditions and the following disclaimer in the 124887Schin * documentation and/or other materials provided with the distribution. 134887Schin * 144887Schin * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 154887Schin * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 164887Schin * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 174887Schin * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 184887Schin * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 194887Schin * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 204887Schin * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 214887Schin * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 224887Schin * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 234887Schin * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 244887Schin * SUCH DAMAGE. 254887Schin * 264887Schin * $FreeBSD: head/sys/amd64/include/atomic.h 254612 2013-08-21 21:14:16Z jkim $ 274887Schin */ 284887Schin#ifndef _MACHINE_ATOMIC_H_ 2912068SRoger.Faulkner@Oracle.COM#define _MACHINE_ATOMIC_H_ 304887Schin 314887Schin#ifndef _SYS_CDEFS_H_ 3210898Sroland.mainz@nrubsig.org#error this file needs sys/cdefs.h as a prerequisite 3310898Sroland.mainz@nrubsig.org#endif 344887Schin 354887Schin#define mb() __asm __volatile("mfence;" : : : "memory") 364887Schin#define wmb() __asm __volatile("sfence;" : : : "memory") 374887Schin#define rmb() __asm __volatile("lfence;" : : : "memory") 3810898Sroland.mainz@nrubsig.org 3910898Sroland.mainz@nrubsig.org/* 404887Schin * Various simple operations on memory, each of which is atomic in the 414887Schin * presence of interrupts and multiple processors. 424887Schin * 434887Schin * atomic_set_char(P, V) (*(u_char *)(P) |= (V)) 444887Schin * atomic_clear_char(P, V) (*(u_char *)(P) &= ~(V)) 454887Schin * atomic_add_char(P, V) (*(u_char *)(P) += (V)) 464887Schin * atomic_subtract_char(P, V) (*(u_char *)(P) -= (V)) 474887Schin * 484887Schin * atomic_set_short(P, V) (*(u_short *)(P) |= (V)) 494887Schin * atomic_clear_short(P, V) (*(u_short *)(P) &= ~(V)) 504887Schin * atomic_add_short(P, V) (*(u_short *)(P) += (V)) 514887Schin * atomic_subtract_short(P, V) (*(u_short *)(P) -= (V)) 5210898Sroland.mainz@nrubsig.org * 5310898Sroland.mainz@nrubsig.org * atomic_set_int(P, V) (*(u_int *)(P) |= (V)) 544887Schin * atomic_clear_int(P, V) (*(u_int *)(P) &= ~(V)) 554887Schin * atomic_add_int(P, V) (*(u_int *)(P) += (V)) 564887Schin * atomic_subtract_int(P, V) (*(u_int *)(P) -= (V)) 574887Schin * atomic_readandclear_int(P) (return (*(u_int *)(P)); *(u_int *)(P) = 0;) 584887Schin * 5910898Sroland.mainz@nrubsig.org * atomic_set_long(P, V) (*(u_long *)(P) |= (V)) 6010898Sroland.mainz@nrubsig.org * atomic_clear_long(P, V) (*(u_long *)(P) &= ~(V)) 614887Schin * atomic_add_long(P, V) (*(u_long *)(P) += (V)) 624887Schin * atomic_subtract_long(P, V) (*(u_long *)(P) -= (V)) 634887Schin * atomic_readandclear_long(P) (return (*(u_long *)(P)); *(u_long *)(P) = 0;) 644887Schin */ 654887Schin 664887Schin/* 674887Schin * The above functions are expanded inline in the statically-linked 684887Schin * kernel. Lock prefixes are generated if an SMP kernel is being 694887Schin * built. 704887Schin * 714887Schin * Kernel modules call real functions which are built into the kernel. 724887Schin * This allows kernel modules to be portable between UP and SMP systems. 734887Schin */ 744887Schin#if defined(KLD_MODULE) || !defined(__GNUCLIKE_ASM) 754887Schin#define ATOMIC_ASM(NAME, TYPE, OP, CONS, V) \ 764887Schinvoid atomic_##NAME##_##TYPE(volatile u_##TYPE *p, u_##TYPE v); \ 774887Schinvoid atomic_##NAME##_barr_##TYPE(volatile u_##TYPE *p, u_##TYPE v) 784887Schin 794887Schinint atomic_cmpset_int(volatile u_int *dst, u_int expect, u_int src); 804887Schinint atomic_cmpset_long(volatile u_long *dst, u_long expect, u_long src); 814887Schinu_int atomic_fetchadd_int(volatile u_int *p, u_int v); 824887Schinu_long atomic_fetchadd_long(volatile u_long *p, u_long v); 834887Schin 844887Schin#define ATOMIC_LOAD(TYPE, LOP) \ 854887Schinu_##TYPE atomic_load_acq_##TYPE(volatile u_##TYPE *p) 864887Schin#define ATOMIC_STORE(TYPE) \ 8712068SRoger.Faulkner@Oracle.COMvoid atomic_store_rel_##TYPE(volatile u_##TYPE *p, u_##TYPE v) 8812068SRoger.Faulkner@Oracle.COM 894887Schin#else /* !KLD_MODULE && __GNUCLIKE_ASM */ 904887Schin 914887Schin/* 924887Schin * For userland, always use lock prefixes so that the binaries will run 934887Schin * on both SMP and !SMP systems. 944887Schin */ 954887Schin#if defined(SMP) || !defined(_KERNEL) 964887Schin#define MPLOCKED "lock ; " 974887Schin#else 984887Schin#define MPLOCKED 994887Schin#endif 1004887Schin 1014887Schin/* 1024887Schin * The assembly is volatilized to avoid code chunk removal by the compiler. 1034887Schin * GCC aggressively reorders operations and memory clobbering is necessary 1044887Schin * in order to avoid that for memory barriers. 10512068SRoger.Faulkner@Oracle.COM */ 1064887Schin#define ATOMIC_ASM(NAME, TYPE, OP, CONS, V) \ 1074887Schinstatic __inline void \ 1084887Schinatomic_##NAME##_##TYPE(volatile u_##TYPE *p, u_##TYPE v)\ 10912068SRoger.Faulkner@Oracle.COM{ \ 11012068SRoger.Faulkner@Oracle.COM __asm __volatile(MPLOCKED OP \ 1114887Schin : "+m" (*p) \ 11212068SRoger.Faulkner@Oracle.COM : CONS (V) \ 1134887Schin : "cc"); \ 11412068SRoger.Faulkner@Oracle.COM} \ 1154887Schin \ 1164887Schinstatic __inline void \ 11712068SRoger.Faulkner@Oracle.COMatomic_##NAME##_barr_##TYPE(volatile u_##TYPE *p, u_##TYPE v)\ 11812068SRoger.Faulkner@Oracle.COM{ \ 11912068SRoger.Faulkner@Oracle.COM __asm __volatile(MPLOCKED OP \ 12012068SRoger.Faulkner@Oracle.COM : "+m" (*p) \ 12112068SRoger.Faulkner@Oracle.COM : CONS (V) \ 12212068SRoger.Faulkner@Oracle.COM : "memory", "cc"); \ 12312068SRoger.Faulkner@Oracle.COM} \ 12412068SRoger.Faulkner@Oracle.COMstruct __hack 12512068SRoger.Faulkner@Oracle.COM 1264887Schin/* 1274887Schin * Atomic compare and set, used by the mutex functions 12812068SRoger.Faulkner@Oracle.COM * 1294887Schin * if (*dst == expect) *dst = src (all 32 bit words) 13012068SRoger.Faulkner@Oracle.COM * 13112068SRoger.Faulkner@Oracle.COM * Returns 0 on failure, non-zero on success 13212068SRoger.Faulkner@Oracle.COM */ 13312068SRoger.Faulkner@Oracle.COM 13412068SRoger.Faulkner@Oracle.COMstatic __inline int 13512068SRoger.Faulkner@Oracle.COMatomic_cmpset_int(volatile u_int *dst, u_int expect, u_int src) 13612068SRoger.Faulkner@Oracle.COM{ 13712068SRoger.Faulkner@Oracle.COM u_char res; 13812068SRoger.Faulkner@Oracle.COM 13912068SRoger.Faulkner@Oracle.COM __asm __volatile( 14012068SRoger.Faulkner@Oracle.COM " " MPLOCKED " " 14112068SRoger.Faulkner@Oracle.COM " cmpxchgl %2,%1 ; " 14212068SRoger.Faulkner@Oracle.COM " sete %0 ; " 14312068SRoger.Faulkner@Oracle.COM "# atomic_cmpset_int" 14412068SRoger.Faulkner@Oracle.COM : "=a" (res), /* 0 */ 14512068SRoger.Faulkner@Oracle.COM "+m" (*dst) /* 1 */ 1464887Schin : "r" (src), /* 2 */ 1474887Schin "a" (expect) /* 3 */ 14812068SRoger.Faulkner@Oracle.COM : "memory", "cc"); 1494887Schin 1504887Schin return (res); 1514887Schin} 1524887Schin 1534887Schinstatic __inline int 1544887Schinatomic_cmpset_long(volatile u_long *dst, u_long expect, u_long src) 1554887Schin{ 1564887Schin u_char res; 1574887Schin 1584887Schin __asm __volatile( 1594887Schin " " MPLOCKED " " 1604887Schin " cmpxchgq %2,%1 ; " 1614887Schin " sete %0 ; " 1624887Schin "# atomic_cmpset_long" 1634887Schin : "=a" (res), /* 0 */ 1644887Schin "+m" (*dst) /* 1 */ 1654887Schin : "r" (src), /* 2 */ 1664887Schin "a" (expect) /* 3 */ 1674887Schin : "memory", "cc"); 1684887Schin 1694887Schin return (res); 17010898Sroland.mainz@nrubsig.org} 17110898Sroland.mainz@nrubsig.org 17210898Sroland.mainz@nrubsig.org/* 17310898Sroland.mainz@nrubsig.org * Atomically add the value of v to the integer pointed to by p and return 17410898Sroland.mainz@nrubsig.org * the previous value of *p. 17510898Sroland.mainz@nrubsig.org */ 17610898Sroland.mainz@nrubsig.orgstatic __inline u_int 17710898Sroland.mainz@nrubsig.orgatomic_fetchadd_int(volatile u_int *p, u_int v) 17810898Sroland.mainz@nrubsig.org{ 1794887Schin 18010898Sroland.mainz@nrubsig.org __asm __volatile( 18110898Sroland.mainz@nrubsig.org " " MPLOCKED " " 18210898Sroland.mainz@nrubsig.org " xaddl %0,%1 ; " 18310898Sroland.mainz@nrubsig.org "# atomic_fetchadd_int" 18410898Sroland.mainz@nrubsig.org : "+r" (v), /* 0 */ 18510898Sroland.mainz@nrubsig.org "+m" (*p) /* 1 */ 18610898Sroland.mainz@nrubsig.org : : "cc"); 18710898Sroland.mainz@nrubsig.org return (v); 18810898Sroland.mainz@nrubsig.org} 1894887Schin 1904887Schin/* 1914887Schin * Atomically add the value of v to the long integer pointed to by p and return 1924887Schin * the previous value of *p. 1934887Schin */ 1944887Schinstatic __inline u_long 1954887Schinatomic_fetchadd_long(volatile u_long *p, u_long v) 1964887Schin{ 1974887Schin 1984887Schin __asm __volatile( 1994887Schin " " MPLOCKED " " 2004887Schin " xaddq %0,%1 ; " 2014887Schin "# atomic_fetchadd_long" 2024887Schin : "+r" (v), /* 0 */ 2034887Schin "+m" (*p) /* 1 */ 2044887Schin : : "cc"); 2054887Schin return (v); 2064887Schin} 2074887Schin 2084887Schin/* 2094887Schin * We assume that a = b will do atomic loads and stores. Due to the 2104887Schin * IA32 memory model, a simple store guarantees release semantics. 2114887Schin * 2124887Schin * However, loads may pass stores, so for atomic_load_acq we have to 2134887Schin * ensure a Store/Load barrier to do the load in SMP kernels. We use 2144887Schin * "lock cmpxchg" as recommended by the AMD Software Optimization 2154887Schin * Guide, and not mfence. For UP kernels, however, the cache of the 2164887Schin * single processor is always consistent, so we only need to take care 2174887Schin * of the compiler. 2184887Schin */ 2194887Schin#define ATOMIC_STORE(TYPE) \ 2204887Schinstatic __inline void \ 2214887Schinatomic_store_rel_##TYPE(volatile u_##TYPE *p, u_##TYPE v)\ 2224887Schin{ \ 2234887Schin __compiler_membar(); \ 2244887Schin *p = v; \ 2254887Schin} \ 2264887Schinstruct __hack 2274887Schin 2284887Schin#if defined(_KERNEL) && !defined(SMP) 2294887Schin 2304887Schin#define ATOMIC_LOAD(TYPE, LOP) \ 2314887Schinstatic __inline u_##TYPE \ 2324887Schinatomic_load_acq_##TYPE(volatile u_##TYPE *p) \ 2334887Schin{ \ 2344887Schin u_##TYPE tmp; \ 2354887Schin \ 2364887Schin tmp = *p; \ 2374887Schin __compiler_membar(); \ 2384887Schin return (tmp); \ 2394887Schin} \ 2404887Schinstruct __hack 2414887Schin 2424887Schin#else /* !(_KERNEL && !SMP) */ 2434887Schin 2444887Schin#define ATOMIC_LOAD(TYPE, LOP) \ 2454887Schinstatic __inline u_##TYPE \ 2464887Schinatomic_load_acq_##TYPE(volatile u_##TYPE *p) \ 2474887Schin{ \ 2484887Schin u_##TYPE res; \ 2494887Schin \ 2504887Schin __asm __volatile(MPLOCKED LOP \ 2514887Schin : "=a" (res), /* 0 */ \ 2524887Schin "+m" (*p) /* 1 */ \ 2534887Schin : : "memory", "cc"); \ 2544887Schin \ 2554887Schin return (res); \ 2564887Schin} \ 2574887Schinstruct __hack 2584887Schin 2594887Schin#endif /* _KERNEL && !SMP */ 2604887Schin 2614887Schin#endif /* KLD_MODULE || !__GNUCLIKE_ASM */ 2624887Schin 2634887SchinATOMIC_ASM(set, char, "orb %b1,%0", "iq", v); 2644887SchinATOMIC_ASM(clear, char, "andb %b1,%0", "iq", ~v); 2654887SchinATOMIC_ASM(add, char, "addb %b1,%0", "iq", v); 2664887SchinATOMIC_ASM(subtract, char, "subb %b1,%0", "iq", v); 2674887Schin 2684887SchinATOMIC_ASM(set, short, "orw %w1,%0", "ir", v); 2694887SchinATOMIC_ASM(clear, short, "andw %w1,%0", "ir", ~v); 2704887SchinATOMIC_ASM(add, short, "addw %w1,%0", "ir", v); 2714887SchinATOMIC_ASM(subtract, short, "subw %w1,%0", "ir", v); 2724887Schin 2734887SchinATOMIC_ASM(set, int, "orl %1,%0", "ir", v); 2744887SchinATOMIC_ASM(clear, int, "andl %1,%0", "ir", ~v); 2754887SchinATOMIC_ASM(add, int, "addl %1,%0", "ir", v); 2764887SchinATOMIC_ASM(subtract, int, "subl %1,%0", "ir", v); 2774887Schin 2784887SchinATOMIC_ASM(set, long, "orq %1,%0", "ir", v); 2794887SchinATOMIC_ASM(clear, long, "andq %1,%0", "ir", ~v); 2804887SchinATOMIC_ASM(add, long, "addq %1,%0", "ir", v); 2814887SchinATOMIC_ASM(subtract, long, "subq %1,%0", "ir", v); 2824887Schin 2834887SchinATOMIC_LOAD(char, "cmpxchgb %b0,%1"); 2844887SchinATOMIC_LOAD(short, "cmpxchgw %w0,%1"); 2854887SchinATOMIC_LOAD(int, "cmpxchgl %0,%1"); 2864887SchinATOMIC_LOAD(long, "cmpxchgq %0,%1"); 2874887Schin 2884887SchinATOMIC_STORE(char); 2894887SchinATOMIC_STORE(short); 2904887SchinATOMIC_STORE(int); 2914887SchinATOMIC_STORE(long); 2924887Schin 2934887Schin#undef ATOMIC_ASM 2944887Schin#undef ATOMIC_LOAD 2954887Schin#undef ATOMIC_STORE 2964887Schin 2974887Schin#ifndef WANT_FUNCTIONS 2984887Schin 2994887Schin/* Read the current value and store a zero in the destination. */ 3004887Schin#ifdef __GNUCLIKE_ASM 3014887Schin 3024887Schinstatic __inline u_int 3034887Schinatomic_readandclear_int(volatile u_int *p) 3044887Schin{ 3054887Schin u_int res; 3064887Schin 3074887Schin res = 0; 3084887Schin __asm __volatile( 3094887Schin " xchgl %1,%0 ; " 3104887Schin "# atomic_readandclear_int" 3114887Schin : "+r" (res), /* 0 */ 3124887Schin "+m" (*p)); /* 1 */ 3134887Schin 3144887Schin return (res); 3154887Schin} 3164887Schin 3174887Schinstatic __inline u_long 3184887Schinatomic_readandclear_long(volatile u_long *p) 3194887Schin{ 3204887Schin u_long res; 3214887Schin 3224887Schin res = 0; 3234887Schin __asm __volatile( 3244887Schin " xchgq %1,%0 ; " 3254887Schin "# atomic_readandclear_long" 3264887Schin : "+r" (res), /* 0 */ 3274887Schin "+m" (*p)); /* 1 */ 3284887Schin 3294887Schin return (res); 3304887Schin} 3314887Schin 3324887Schin#else /* !__GNUCLIKE_ASM */ 3334887Schin 3344887Schinu_int atomic_readandclear_int(volatile u_int *p); 3354887Schinu_long atomic_readandclear_long(volatile u_long *p); 3364887Schin 3374887Schin#endif /* __GNUCLIKE_ASM */ 3384887Schin 339#define atomic_set_acq_char atomic_set_barr_char 340#define atomic_set_rel_char atomic_set_barr_char 341#define atomic_clear_acq_char atomic_clear_barr_char 342#define atomic_clear_rel_char atomic_clear_barr_char 343#define atomic_add_acq_char atomic_add_barr_char 344#define atomic_add_rel_char atomic_add_barr_char 345#define atomic_subtract_acq_char atomic_subtract_barr_char 346#define atomic_subtract_rel_char atomic_subtract_barr_char 347 348#define atomic_set_acq_short atomic_set_barr_short 349#define atomic_set_rel_short atomic_set_barr_short 350#define atomic_clear_acq_short atomic_clear_barr_short 351#define atomic_clear_rel_short atomic_clear_barr_short 352#define atomic_add_acq_short atomic_add_barr_short 353#define atomic_add_rel_short atomic_add_barr_short 354#define atomic_subtract_acq_short atomic_subtract_barr_short 355#define atomic_subtract_rel_short atomic_subtract_barr_short 356 357#define atomic_set_acq_int atomic_set_barr_int 358#define atomic_set_rel_int atomic_set_barr_int 359#define atomic_clear_acq_int atomic_clear_barr_int 360#define atomic_clear_rel_int atomic_clear_barr_int 361#define atomic_add_acq_int atomic_add_barr_int 362#define atomic_add_rel_int atomic_add_barr_int 363#define atomic_subtract_acq_int atomic_subtract_barr_int 364#define atomic_subtract_rel_int atomic_subtract_barr_int 365#define atomic_cmpset_acq_int atomic_cmpset_int 366#define atomic_cmpset_rel_int atomic_cmpset_int 367 368#define atomic_set_acq_long atomic_set_barr_long 369#define atomic_set_rel_long atomic_set_barr_long 370#define atomic_clear_acq_long atomic_clear_barr_long 371#define atomic_clear_rel_long atomic_clear_barr_long 372#define atomic_add_acq_long atomic_add_barr_long 373#define atomic_add_rel_long atomic_add_barr_long 374#define atomic_subtract_acq_long atomic_subtract_barr_long 375#define atomic_subtract_rel_long atomic_subtract_barr_long 376#define atomic_cmpset_acq_long atomic_cmpset_long 377#define atomic_cmpset_rel_long atomic_cmpset_long 378 379/* Operations on 8-bit bytes. */ 380#define atomic_set_8 atomic_set_char 381#define atomic_set_acq_8 atomic_set_acq_char 382#define atomic_set_rel_8 atomic_set_rel_char 383#define atomic_clear_8 atomic_clear_char 384#define atomic_clear_acq_8 atomic_clear_acq_char 385#define atomic_clear_rel_8 atomic_clear_rel_char 386#define atomic_add_8 atomic_add_char 387#define atomic_add_acq_8 atomic_add_acq_char 388#define atomic_add_rel_8 atomic_add_rel_char 389#define atomic_subtract_8 atomic_subtract_char 390#define atomic_subtract_acq_8 atomic_subtract_acq_char 391#define atomic_subtract_rel_8 atomic_subtract_rel_char 392#define atomic_load_acq_8 atomic_load_acq_char 393#define atomic_store_rel_8 atomic_store_rel_char 394 395/* Operations on 16-bit words. */ 396#define atomic_set_16 atomic_set_short 397#define atomic_set_acq_16 atomic_set_acq_short 398#define atomic_set_rel_16 atomic_set_rel_short 399#define atomic_clear_16 atomic_clear_short 400#define atomic_clear_acq_16 atomic_clear_acq_short 401#define atomic_clear_rel_16 atomic_clear_rel_short 402#define atomic_add_16 atomic_add_short 403#define atomic_add_acq_16 atomic_add_acq_short 404#define atomic_add_rel_16 atomic_add_rel_short 405#define atomic_subtract_16 atomic_subtract_short 406#define atomic_subtract_acq_16 atomic_subtract_acq_short 407#define atomic_subtract_rel_16 atomic_subtract_rel_short 408#define atomic_load_acq_16 atomic_load_acq_short 409#define atomic_store_rel_16 atomic_store_rel_short 410 411/* Operations on 32-bit double words. */ 412#define atomic_set_32 atomic_set_int 413#define atomic_set_acq_32 atomic_set_acq_int 414#define atomic_set_rel_32 atomic_set_rel_int 415#define atomic_clear_32 atomic_clear_int 416#define atomic_clear_acq_32 atomic_clear_acq_int 417#define atomic_clear_rel_32 atomic_clear_rel_int 418#define atomic_add_32 atomic_add_int 419#define atomic_add_acq_32 atomic_add_acq_int 420#define atomic_add_rel_32 atomic_add_rel_int 421#define atomic_subtract_32 atomic_subtract_int 422#define atomic_subtract_acq_32 atomic_subtract_acq_int 423#define atomic_subtract_rel_32 atomic_subtract_rel_int 424#define atomic_load_acq_32 atomic_load_acq_int 425#define atomic_store_rel_32 atomic_store_rel_int 426#define atomic_cmpset_32 atomic_cmpset_int 427#define atomic_cmpset_acq_32 atomic_cmpset_acq_int 428#define atomic_cmpset_rel_32 atomic_cmpset_rel_int 429#define atomic_readandclear_32 atomic_readandclear_int 430#define atomic_fetchadd_32 atomic_fetchadd_int 431 432/* Operations on 64-bit quad words. */ 433#define atomic_set_64 atomic_set_long 434#define atomic_set_acq_64 atomic_set_acq_long 435#define atomic_set_rel_64 atomic_set_rel_long 436#define atomic_clear_64 atomic_clear_long 437#define atomic_clear_acq_64 atomic_clear_acq_long 438#define atomic_clear_rel_64 atomic_clear_rel_long 439#define atomic_add_64 atomic_add_long 440#define atomic_add_acq_64 atomic_add_acq_long 441#define atomic_add_rel_64 atomic_add_rel_long 442#define atomic_subtract_64 atomic_subtract_long 443#define atomic_subtract_acq_64 atomic_subtract_acq_long 444#define atomic_subtract_rel_64 atomic_subtract_rel_long 445#define atomic_load_acq_64 atomic_load_acq_long 446#define atomic_store_rel_64 atomic_store_rel_long 447#define atomic_cmpset_64 atomic_cmpset_long 448#define atomic_cmpset_acq_64 atomic_cmpset_acq_long 449#define atomic_cmpset_rel_64 atomic_cmpset_rel_long 450#define atomic_readandclear_64 atomic_readandclear_long 451 452/* Operations on pointers. */ 453#define atomic_set_ptr atomic_set_long 454#define atomic_set_acq_ptr atomic_set_acq_long 455#define atomic_set_rel_ptr atomic_set_rel_long 456#define atomic_clear_ptr atomic_clear_long 457#define atomic_clear_acq_ptr atomic_clear_acq_long 458#define atomic_clear_rel_ptr atomic_clear_rel_long 459#define atomic_add_ptr atomic_add_long 460#define atomic_add_acq_ptr atomic_add_acq_long 461#define atomic_add_rel_ptr atomic_add_rel_long 462#define atomic_subtract_ptr atomic_subtract_long 463#define atomic_subtract_acq_ptr atomic_subtract_acq_long 464#define atomic_subtract_rel_ptr atomic_subtract_rel_long 465#define atomic_load_acq_ptr atomic_load_acq_long 466#define atomic_store_rel_ptr atomic_store_rel_long 467#define atomic_cmpset_ptr atomic_cmpset_long 468#define atomic_cmpset_acq_ptr atomic_cmpset_acq_long 469#define atomic_cmpset_rel_ptr atomic_cmpset_rel_long 470#define atomic_readandclear_ptr atomic_readandclear_long 471 472#endif /* !WANT_FUNCTIONS */ 473 474#endif /* !_MACHINE_ATOMIC_H_ */ 475