lib/Support/Atomic.cpp

   1 //===-- Atomic.cpp - 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 header file implements atomic operations.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Support/Atomic.h"
  15 #include "llvm/Config/llvm-config.h"
  16
  17 using namespace llvm;
  18
  19 #if defined(_MSC_VER)
  20 #include <windows.h>
  21 #undef MemoryFence
  22 #endif
  23
  24 #if defined(__GNUC__) || (defined(__IBMCPP__) && __IBMCPP__ >= 1210)
  25 #define GNU_ATOMICS
  26 #endif
  27
  28 void sys::MemoryFence() {
  29 #if LLVM_HAS_ATOMICS == 0
  30   return;
  31 #else
  32 #  if defined(GNU_ATOMICS)
  33   __sync_synchronize();
  34 #  elif defined(_MSC_VER)
  35   MemoryBarrier();
  36 #  else
  37 # error No memory fence implementation for your platform!
  38 #  endif
  39 #endif
  40 }
  41
  42 sys::cas_flag sys::CompareAndSwap(volatile sys::cas_flag* ptr,
  43                                   sys::cas_flag new_value,
  44                                   sys::cas_flag old_value) {
  45 #if LLVM_HAS_ATOMICS == 0
  46   sys::cas_flag result = *ptr;
  47   if (result == old_value)
  48     *ptr = new_value;
  49   return result;
  50 #elif defined(GNU_ATOMICS)
  51   return __sync_val_compare_and_swap(ptr, old_value, new_value);
  52 #elif defined(_MSC_VER)
  53   return InterlockedCompareExchange(ptr, new_value, old_value);
  54 #else
  55 #  error No compare-and-swap implementation for your platform!
  56 #endif
  57 }
  58
  59 sys::cas_flag sys::AtomicIncrement(volatile sys::cas_flag* ptr) {
  60 #if LLVM_HAS_ATOMICS == 0
  61   ++(*ptr);
  62   return *ptr;
  63 #elif defined(GNU_ATOMICS)
  64   return __sync_add_and_fetch(ptr, 1);
  65 #elif defined(_MSC_VER)
  66   return InterlockedIncrement(ptr);
  67 #else
  68 #  error No atomic increment implementation for your platform!
  69 #endif
  70 }
  71
  72 sys::cas_flag sys::AtomicDecrement(volatile sys::cas_flag* ptr) {
  73 #if LLVM_HAS_ATOMICS == 0
  74   --(*ptr);
  75   return *ptr;
  76 #elif defined(GNU_ATOMICS)
  77   return __sync_sub_and_fetch(ptr, 1);
  78 #elif defined(_MSC_VER)
  79   return InterlockedDecrement(ptr);
  80 #else
  81 #  error No atomic decrement implementation for your platform!
  82 #endif
  83 }
  84
  85 sys::cas_flag sys::AtomicAdd(volatile sys::cas_flag* ptr, sys::cas_flag val) {
  86 #if LLVM_HAS_ATOMICS == 0
  87   *ptr += val;
  88   return *ptr;
  89 #elif defined(GNU_ATOMICS)
  90   return __sync_add_and_fetch(ptr, val);
  91 #elif defined(_MSC_VER)
  92   return InterlockedExchangeAdd(ptr, val) + val;
  93 #else
  94 #  error No atomic add implementation for your platform!
  95 #endif
  96 }
  97
  98 sys::cas_flag sys::AtomicMul(volatile sys::cas_flag* ptr, sys::cas_flag val) {
  99   sys::cas_flag original, result;
 100   do {
 101     original = *ptr;
 102     result = original * val;
 103   } while (sys::CompareAndSwap(ptr, result, original) != original);
 104
 105   return result;
 106 }
 107
 108 sys::cas_flag sys::AtomicDiv(volatile sys::cas_flag* ptr, sys::cas_flag val) {
 109   sys::cas_flag original, result;
 110   do {
 111     original = *ptr;
 112     result = original / val;
 113   } while (sys::CompareAndSwap(ptr, result, original) != original);
 114
 115   return result;
 116 }