contrib/bind9/lib/isc/x86_32/include/isc/atomic.h

   1 /*
   2  * Copyright (C) 2005, 2007, 2008, 2015  Internet Systems Consortium, Inc. ("ISC")
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
   9  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  10  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  11  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  12  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  13  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  14  * PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 /* $Id: atomic.h,v 1.10 2008/01/24 23:47:00 tbox Exp $ */
  18
  19 #ifndef ISC_ATOMIC_H
  20 #define ISC_ATOMIC_H 1
  21
  22 #include <isc/platform.h>
  23 #include <isc/types.h>
  24
  25 #ifdef ISC_PLATFORM_USEGCCASM
  26 /*
  27  * This routine atomically increments the value stored in 'p' by 'val', and
  28  * returns the previous value.
  29  */
  30 static __inline__ isc_int32_t
  31 isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
  32         isc_int32_t prev = val;
  33
  34         __asm__ volatile(
  35 #ifdef ISC_PLATFORM_USETHREADS
  36                 "lock;"
  37 #endif
  38                 "xadd %0, %1"
  39                 :"=q"(prev)
  40                 :"m"(*p), "0"(prev)
  41                 :"memory", "cc");
  42
  43         return (prev);
  44 }
  45
  46 #ifdef ISC_PLATFORM_HAVEXADDQ
  47 static __inline__ isc_int64_t
  48 isc_atomic_xaddq(isc_int64_t *p, isc_int64_t val) {
  49         isc_int64_t prev = val;
  50
  51         __asm__ volatile(
  52 #ifdef ISC_PLATFORM_USETHREADS
  53             "lock;"
  54 #endif
  55             "xaddq %0, %1"
  56             :"=q"(prev)
  57             :"m"(*p), "0"(prev)
  58             :"memory", "cc");
  59
  60         return (prev);
  61 }
  62 #endif /* ISC_PLATFORM_HAVEXADDQ */
  63
  64 /*
  65  * This routine atomically stores the value 'val' in 'p' (32-bit version).
  66  */
  67 static __inline__ void
  68 isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
  69         __asm__ volatile(
  70 #ifdef ISC_PLATFORM_USETHREADS
  71                 /*
  72                  * xchg should automatically lock memory, but we add it
  73                  * explicitly just in case (it at least doesn't harm)
  74                  */
  75                 "lock;"
  76 #endif
  77
  78                 "xchgl %1, %0"
  79                 :
  80                 : "r"(val), "m"(*p)
  81                 : "memory");
  82 }
  83
  84 #ifdef ISC_PLATFORM_HAVEATOMICSTOREQ
  85 /*
  86  * This routine atomically stores the value 'val' in 'p' (64-bit version).
  87  */
  88 static __inline__ void
  89 isc_atomic_storeq(isc_int64_t *p, isc_int64_t val) {
  90         __asm__ volatile(
  91 #ifdef ISC_PLATFORM_USETHREADS
  92                 /*
  93                  * xchg should automatically lock memory, but we add it
  94                  * explicitly just in case (it at least doesn't harm)
  95                  */
  96                 "lock;"
  97 #endif
  98
  99                 "xchgq %1, %0"
 100                 :
 101                 : "r"(val), "m"(*p)
 102                 : "memory");
 103 }
 104 #endif /* ISC_PLATFORM_HAVEATOMICSTOREQ */
 105
 106 /*
 107  * This routine atomically replaces the value in 'p' with 'val', if the
 108  * original value is equal to 'cmpval'.  The original value is returned in any
 109  * case.
 110  */
 111 static __inline__ isc_int32_t
 112 isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
 113         __asm__ volatile(
 114 #ifdef ISC_PLATFORM_USETHREADS
 115                 "lock;"
 116 #endif
 117                 "cmpxchgl %1, %2"
 118                 : "=a"(cmpval)
 119                 : "r"(val), "m"(*p), "a"(cmpval)
 120                 : "memory");
 121
 122         return (cmpval);
 123 }
 124
 125 #elif defined(ISC_PLATFORM_USESTDASM)
 126 /*
 127  * The followings are "generic" assembly code which implements the same
 128  * functionality in case the gcc extension cannot be used.  It should be
 129  * better to avoid inlining below, since we directly refer to specific
 130  * positions of the stack frame, which would not actually point to the
 131  * intended address in the embedded mnemonic.
 132  */
 133 #include <isc/util.h>           /* for 'UNUSED' macro */
 134
 135 static isc_int32_t
 136 isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
 137         UNUSED(p);
 138         UNUSED(val);
 139
 140         __asm (
 141                 "movl 8(%ebp), %ecx\n"
 142                 "movl 12(%ebp), %edx\n"
 143 #ifdef ISC_PLATFORM_USETHREADS
 144                 "lock;"
 145 #endif
 146                 "xadd %edx, (%ecx)\n"
 147
 148                 /*
 149                  * set the return value directly in the register so that we
 150                  * can avoid guessing the correct position in the stack for a
 151                  * local variable.
 152                  */
 153                 "movl %edx, %eax"
 154                 );
 155 }
 156
 157 static void
 158 isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
 159         UNUSED(p);
 160         UNUSED(val);
 161
 162         __asm (
 163                 "movl 8(%ebp), %ecx\n"
 164                 "movl 12(%ebp), %edx\n"
 165 #ifdef ISC_PLATFORM_USETHREADS
 166                 "lock;"
 167 #endif
 168                 "xchgl (%ecx), %edx\n"
 169                 );
 170 }
 171
 172 static isc_int32_t
 173 isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
 174         UNUSED(p);
 175         UNUSED(cmpval);
 176         UNUSED(val);
 177
 178         __asm (
 179                 "movl 8(%ebp), %ecx\n"
 180                 "movl 12(%ebp), %eax\n" /* must be %eax for cmpxchgl */
 181                 "movl 16(%ebp), %edx\n"
 182 #ifdef ISC_PLATFORM_USETHREADS
 183                 "lock;"
 184 #endif
 185
 186                 /*
 187                  * If (%ecx) == %eax then (%ecx) := %edx.
 188                  % %eax is set to old (%ecx), which will be the return value.
 189                  */
 190                 "cmpxchgl %edx, (%ecx)"
 191                 );
 192 }
 193 #else /* !ISC_PLATFORM_USEGCCASM && !ISC_PLATFORM_USESTDASM */
 194
 195 #error "unsupported compiler.  disable atomic ops by --disable-atomic"
 196
 197 #endif
 198 #endif /* ISC_ATOMIC_H */