include/llvm/System/Atomic.h

   1 //===- llvm/System/Atomic.h - Atomic Operations -----------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares the llvm::sys atomic operations.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_SYSTEM_ATOMIC_H
  15 #define LLVM_SYSTEM_ATOMIC_H
  16
  17 #if defined(_MSC_VER)
  18 #include <windows.h>
  19 #endif
  20
  21
  22 namespace llvm {
  23   namespace sys {
  24
  25     inline void MemoryFence() {
  26 #if LLVM_MULTITHREADED==0
  27       return;
  28 #else
  29 #  if defined(__GNUC__)
  30       __sync_synchronize();
  31 #  elif defined(_MSC_VER)
  32       MemoryBarrier();
  33 #  else
  34 #    error No memory fence implementation for your platform!
  35 #  endif
  36 #endif
  37 }
  38
  39 #if LLVM_MULTITHREADED==0
  40     typedef unsigned long cas_flag;
  41     template<typename T>
  42     inline T CompareAndSwap(volatile T* dest,
  43                             T exc, T c) {
  44       T result = *dest;
  45       if (result == c)
  46         *dest = exc;
  47       return result;
  48     }
  49 #elif defined(__GNUC__)
  50     typedef unsigned long cas_flag;
  51     template<typename T>
  52     inline T CompareAndSwap(volatile T* ptr,
  53                             T new_value,
  54                             T old_value) {
  55       return __sync_val_compare_and_swap(ptr, old_value, new_value);
  56     }
  57 #elif defined(_MSC_VER)
  58     typedef LONG cas_flag;
  59     template<typename T>
  60     inline T CompareAndSwap(volatile T* ptr,
  61                             T new_value,
  62                             T old_value) {
  63       if (sizeof(T) == 4)
  64         return InterlockedCompareExchange(ptr, new_value, old_value);
  65       else if (sizeof(T) == 8)
  66         return InterlockedCompareExchange64(ptr, new_value, old_value);
  67       else
  68         assert(0 && "Unsupported compare-and-swap size!");
  69     }
  70
  71     template<typename T>
  72     inline T* CompareAndSwap<T*>(volatile T** ptr,
  73                                  T* new_value,
  74                                  T* old_value) {
  75       return InterlockedCompareExchangePtr(ptr, new_value, old_value);
  76     }
  77
  78
  79 #else
  80 #  error No compare-and-swap implementation for your platform!
  81 #endif
  82
  83   }
  84 }
  85
  86 #endif