src/runtime/pseudo-atomic.h

   1 /*
   2  * macros for manipulating pseudo-atomic flags (per thread)
   3  */
   4
   5 /*
   6  * This software is part of the SBCL system. See the README file for
   7  * more information.
   8  *
   9  * This software is derived from the CMU CL system, which was
  10  * written at Carnegie Mellon University and released into the
  11  * public domain. The software is in the public domain and is
  12  * provided with absolutely no warranty. See the COPYING and CREDITS
  13  * files for more information.
  14  */
  15
  16 #ifndef PSEUDO_ATOMIC_H
  17 #define PSEUDO_ATOMIC_H
  18
  19 #if defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)
  20
  21 #define set_alloc_pointer(value)                \
  22     SetSymbolValue(ALLOCATION_POINTER, value, 0)
  23 #define get_alloc_pointer()                     \
  24     SymbolValue(ALLOCATION_POINTER, 0)
  25
  26 #if defined(LISP_FEATURE_X86)
  27 #define LISPOBJ_ASM_SUFFIX "l"
  28 #elif defined(LISP_FEATURE_X86_64)
  29 #define LISPOBJ_ASM_SUFFIX "q"
  30 #endif
  31
  32 static inline int
  33 get_pseudo_atomic_atomic(struct thread *thread)
  34 {
  35     return SymbolValue(PSEUDO_ATOMIC_BITS, thread) & (~1);
  36 }
  37
  38 static inline void
  39 set_pseudo_atomic_atomic(struct thread *thread)
  40 {
  41     lispobj *p = SymbolValueAddress(PSEUDO_ATOMIC_BITS, thread);
  42     if (*p)
  43         lose("set_pseudo_atomic_atomic: pseudo atomic bits is %d.", *p);
  44     __asm__ __volatile__
  45         ("or" LISPOBJ_ASM_SUFFIX " %0,%1"
  46          :
  47          : "g" (~1), "m" (*p)
  48          : "memory");
  49 }
  50
  51 static inline void
  52 clear_pseudo_atomic_atomic(struct thread *thread)
  53 {
  54     lispobj *p = SymbolValueAddress(PSEUDO_ATOMIC_BITS, thread);
  55     __asm__ __volatile__
  56         ("and" LISPOBJ_ASM_SUFFIX " %0,%1"
  57          :
  58          : "g" (1), "m" (*p)
  59          : "memory");
  60 }
  61
  62 static inline int
  63 get_pseudo_atomic_interrupted(struct thread *thread)
  64 {
  65     return SymbolValue(PSEUDO_ATOMIC_BITS, thread) & 1;
  66 }
  67
  68 static inline void
  69 set_pseudo_atomic_interrupted(struct thread *thread)
  70 {
  71     if (!get_pseudo_atomic_atomic(thread))
  72         lose("set_pseudo_atomic_interrupted not in pseudo atomic");
  73     lispobj *p = SymbolValueAddress(PSEUDO_ATOMIC_BITS, thread);
  74     __asm__ __volatile__
  75         ("or" LISPOBJ_ASM_SUFFIX " %0,%1"
  76          :
  77          : "g" (1), "m" (*p)
  78          : "memory");
  79 }
  80
  81 static inline void
  82 clear_pseudo_atomic_interrupted(struct thread *thread)
  83 {
  84     if (get_pseudo_atomic_atomic(thread))
  85         lose("clear_pseudo_atomic_interrupted in pseudo atomic");
  86     lispobj *p = SymbolValueAddress(PSEUDO_ATOMIC_BITS, thread);
  87     __asm__ __volatile__
  88         ("and" LISPOBJ_ASM_SUFFIX " %0,%1"
  89          :
  90          : "g" (~1), "m" (*p)
  91          : "memory");
  92 }
  93
  94 #undef LISPOBJ_ASM_SUFFIX
  95
  96 #elif defined(LISP_FEATURE_ARM)
  97 static inline int
  98 get_pseudo_atomic_atomic(struct thread *thread)
  99 {
 100     return SymbolValue(PSEUDO_ATOMIC_ATOMIC, thread) != NIL;
 101 }
 102
 103 static inline void
 104 set_pseudo_atomic_atomic(struct thread *thread)
 105 {
 106     SetSymbolValue(PSEUDO_ATOMIC_ATOMIC, PSEUDO_ATOMIC_ATOMIC, thread);
 107 }
 108
 109 static inline void
 110 clear_pseudo_atomic_atomic(struct thread *thread)
 111 {
 112     SetSymbolValue(PSEUDO_ATOMIC_ATOMIC, NIL, thread);
 113 }
 114
 115 static inline int
 116 get_pseudo_atomic_interrupted(struct thread *thread)
 117 {
 118     return SymbolValue(PSEUDO_ATOMIC_INTERRUPTED, thread) != 0;
 119 }
 120
 121 static inline void
 122 set_pseudo_atomic_interrupted(struct thread *thread)
 123 {
 124     SetSymbolValue(PSEUDO_ATOMIC_INTERRUPTED, do_pending_interrupt, thread);
 125 }
 126
 127 static inline void
 128 clear_pseudo_atomic_interrupted(struct thread *thread)
 129 {
 130     SetSymbolValue(PSEUDO_ATOMIC_INTERRUPTED, 0, 0);
 131 }
 132
 133 #define set_alloc_pointer(value)                \
 134     SetSymbolValue(ALLOCATION_POINTER, value, 0)
 135 #define get_alloc_pointer()                     \
 136     SymbolValue(ALLOCATION_POINTER, 0)
 137
 138 #elif defined(LISP_FEATURE_GENCGC)
 139
 140 /* FIXME: Are these async signal safe? Compiler reordering? */
 141
 142 #define set_alloc_pointer(value) \
 143     (dynamic_space_free_pointer = \
 144      ((lispobj *) \
 145       ((value) | (((uword_t)dynamic_space_free_pointer) & LOWTAG_MASK))))
 146
 147 #define get_alloc_pointer()                                     \
 148     ((uword_t) dynamic_space_free_pointer & ~LOWTAG_MASK)
 149
 150 #ifdef LISP_FEATURE_SB_THREAD
 151 #define get_pseudo_atomic_atomic(thread) \
 152     ((thread)->pseudo_atomic_bits & flag_PseudoAtomic)
 153 #define set_pseudo_atomic_atomic(thread) \
 154     ((thread)->pseudo_atomic_bits |= flag_PseudoAtomic)
 155 #define clear_pseudo_atomic_atomic(thread) \
 156     ((thread)->pseudo_atomic_bits &= ~flag_PseudoAtomic)
 157 #define get_pseudo_atomic_interrupted(thread) \
 158     ((thread)->pseudo_atomic_bits & flag_PseudoAtomicInterrupted)
 159 #define set_pseudo_atomic_interrupted(thread) \
 160     ((thread)->pseudo_atomic_bits |= flag_PseudoAtomicInterrupted)
 161 #define clear_pseudo_atomic_interrupted(thread) \
 162     ((thread)->pseudo_atomic_bits &= ~flag_PseudoAtomicInterrupted)
 163 #else
 164 #define get_pseudo_atomic_atomic(thread)                                \
 165     ((uword_t)dynamic_space_free_pointer & flag_PseudoAtomic)
 166 #define set_pseudo_atomic_atomic(thread)                                \
 167     (dynamic_space_free_pointer                                         \
 168      = (lispobj*) ((uword_t)dynamic_space_free_pointer | flag_PseudoAtomic))
 169 #define clear_pseudo_atomic_atomic(thread)                              \
 170     (dynamic_space_free_pointer                                         \
 171      = (lispobj*) ((uword_t) dynamic_space_free_pointer & ~flag_PseudoAtomic))
 172 #define get_pseudo_atomic_interrupted(thread)                           \
 173     ((uword_t) dynamic_space_free_pointer & flag_PseudoAtomicInterrupted)
 174 #define clear_pseudo_atomic_interrupted(thread)                         \
 175     (dynamic_space_free_pointer                                         \
 176      = (lispobj*) ((uword_t) dynamic_space_free_pointer & ~flag_PseudoAtomicInterrupted))
 177 #define set_pseudo_atomic_interrupted(thread)                           \
 178     (dynamic_space_free_pointer                                         \
 179      = (lispobj*) ((uword_t) dynamic_space_free_pointer | flag_PseudoAtomicInterrupted))
 180 #endif
 181
 182 #endif
 183
 184 #endif /* PSEUDO_ATOMIC_H */