LLVM API Documentation

Atomic.cpp

Go to the documentation of this file.
00001 //===-- Atomic.cpp - Atomic Operations --------------------------*- C++ -*-===//
00002 //
00003 //                     The LLVM Compiler Infrastructure
00004 //
00005 // This file is distributed under the University of Illinois Open Source
00006 // License. See LICENSE.TXT for details.
00007 //
00008 //===----------------------------------------------------------------------===//
00009 //
00010 //  This header file implements atomic operations.
00011 //
00012 //===----------------------------------------------------------------------===//
00013 
00014 #include "llvm/System/Atomic.h"
00015 #include "llvm/Config/config.h"
00016 
00017 using namespace llvm;
00018 
00019 #if defined(_MSC_VER)
00020 #include <windows.h>
00021 #undef MemoryFence
00022 #endif
00023 
00024 void sys::MemoryFence() {
00025 #if LLVM_MULTITHREADED==0
00026   return;
00027 #else
00028 #  if defined(__GNUC__)
00029   __sync_synchronize();
00030 #  elif defined(_MSC_VER)
00031   MemoryBarrier();
00032 #  else
00033 # error No memory fence implementation for your platform!
00034 #  endif
00035 #endif
00036 }
00037 
00038 sys::cas_flag sys::CompareAndSwap(volatile sys::cas_flag* ptr,
00039                                   sys::cas_flag new_value,
00040                                   sys::cas_flag old_value) {
00041 #if LLVM_MULTITHREADED==0
00042   sys::cas_flag result = *ptr;
00043   if (result == old_value)
00044     *ptr = new_value;
00045   return result;
00046 #elif defined(__GNUC__)
00047   return __sync_val_compare_and_swap(ptr, old_value, new_value);
00048 #elif defined(_MSC_VER)
00049   return InterlockedCompareExchange(ptr, new_value, old_value);
00050 #else
00051 #  error No compare-and-swap implementation for your platform!
00052 #endif
00053 }
00054 
00055 sys::cas_flag sys::AtomicIncrement(volatile sys::cas_flag* ptr) {
00056 #if LLVM_MULTITHREADED==0
00057   ++(*ptr);
00058   return *ptr;
00059 #elif defined(__GNUC__)
00060   return __sync_add_and_fetch(ptr, 1);
00061 #elif defined(_MSC_VER)
00062   return InterlockedIncrement(ptr);
00063 #else
00064 #  error No atomic increment implementation for your platform!
00065 #endif
00066 }
00067 
00068 sys::cas_flag sys::AtomicDecrement(volatile sys::cas_flag* ptr) {
00069 #if LLVM_MULTITHREADED==0
00070   --(*ptr);
00071   return *ptr;
00072 #elif defined(__GNUC__)
00073   return __sync_sub_and_fetch(ptr, 1);
00074 #elif defined(_MSC_VER)
00075   return InterlockedDecrement(ptr);
00076 #else
00077 #  error No atomic decrement implementation for your platform!
00078 #endif
00079 }
00080 
00081 sys::cas_flag sys::AtomicAdd(volatile sys::cas_flag* ptr, sys::cas_flag val) {
00082 #if LLVM_MULTITHREADED==0
00083   *ptr += val;
00084   return *ptr;
00085 #elif defined(__GNUC__)
00086   return __sync_add_and_fetch(ptr, val);
00087 #elif defined(_MSC_VER)
00088   return InterlockedAdd(ptr, val);
00089 #else
00090 #  error No atomic add implementation for your platform!
00091 #endif
00092 }
00093 
00094 sys::cas_flag sys::AtomicMul(volatile sys::cas_flag* ptr, sys::cas_flag val) {
00095   sys::cas_flag original, result;
00096   do {
00097     original = *ptr;
00098     result = original * val;
00099   } while (sys::CompareAndSwap(ptr, result, original) != original);
00100 
00101   return result;
00102 }
00103 
00104 sys::cas_flag sys::AtomicDiv(volatile sys::cas_flag* ptr, sys::cas_flag val) {
00105   sys::cas_flag original, result;
00106   do {
00107     original = *ptr;
00108     result = original / val;
00109   } while (sys::CompareAndSwap(ptr, result, original) != original);
00110 
00111   return result;
00112 }