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