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_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) != NIL;
 119 }
 120
 121 static inline void
 122 set_pseudo_atomic_interrupted(struct thread *thread)
 123 {
 124     SetSymbolValue(PSEUDO_ATOMIC_INTERRUPTED, MAKE_FIXNUM(0x000f0001), thread);
 125 }
 126
 127 static inline void
 128 clear_pseudo_atomic_interrupted(struct thread *thread)
 129 {
 130     SetSymbolValue(PSEUDO_ATOMIC_INTERRUPTED, NIL, 0);
 131 }
 132
 133 #define set_alloc_pointer(value) \
 134     (dynamic_space_free_pointer = \
 135      ((lispobj *) \
 136       ((value) | (((uword_t)dynamic_space_free_pointer) & LOWTAG_MASK))))
 137
 138 #define get_alloc_pointer()                                     \
 139     ((uword_t) dynamic_space_free_pointer & ~LOWTAG_MASK)
 140
 141 #elif defined(LISP_FEATURE_GENCGC)
 142
 143 /* FIXME: Are these async signal safe? Compiler reordering? */
 144
 145 #define set_alloc_pointer(value) \
 146     (dynamic_space_free_pointer = \
 147      ((lispobj *) \
 148       ((value) | (((uword_t)dynamic_space_free_pointer) & LOWTAG_MASK))))
 149
 150 #define get_alloc_pointer()                                     \
 151     ((uword_t) dynamic_space_free_pointer & ~LOWTAG_MASK)
 152
 153 #ifdef LISP_FEATURE_SB_THREAD
 154 #define get_pseudo_atomic_atomic(thread) \
 155     ((thread)->pseudo_atomic_bits & flag_PseudoAtomic)
 156 #define set_pseudo_atomic_atomic(thread) \
 157     ((thread)->pseudo_atomic_bits |= flag_PseudoAtomic)
 158 #define clear_pseudo_atomic_atomic(thread) \
 159     ((thread)->pseudo_atomic_bits &= ~flag_PseudoAtomic)
 160 #define get_pseudo_atomic_interrupted(thread) \
 161     ((thread)->pseudo_atomic_bits & flag_PseudoAtomicInterrupted)
 162 #define set_pseudo_atomic_interrupted(thread) \
 163     ((thread)->pseudo_atomic_bits |= flag_PseudoAtomicInterrupted)
 164 #define clear_pseudo_atomic_interrupted(thread) \
 165     ((thread)->pseudo_atomic_bits &= ~flag_PseudoAtomicInterrupted)
 166 #else
 167 #define get_pseudo_atomic_atomic(thread)                                \
 168     ((uword_t)dynamic_space_free_pointer & flag_PseudoAtomic)
 169 #define set_pseudo_atomic_atomic(thread)                                \
 170     (dynamic_space_free_pointer                                         \
 171      = (lispobj*) ((uword_t)dynamic_space_free_pointer | flag_PseudoAtomic))
 172 #define clear_pseudo_atomic_atomic(thread)                              \
 173     (dynamic_space_free_pointer                                         \
 174      = (lispobj*) ((uword_t) dynamic_space_free_pointer & ~flag_PseudoAtomic))
 175 #define get_pseudo_atomic_interrupted(thread)                           \
 176     ((uword_t) dynamic_space_free_pointer & flag_PseudoAtomicInterrupted)
 177 #define clear_pseudo_atomic_interrupted(thread)                         \
 178     (dynamic_space_free_pointer                                         \
 179      = (lispobj*) ((uword_t) dynamic_space_free_pointer & ~flag_PseudoAtomicInterrupted))
 180 #define set_pseudo_atomic_interrupted(thread)                           \
 181     (dynamic_space_free_pointer                                         \
 182      = (lispobj*) ((uword_t) dynamic_space_free_pointer | flag_PseudoAtomicInterrupted))
 183 #endif
 184
 185 #endif
 186
 187 #endif /* PSEUDO_ATOMIC_H */
 188