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
MemoryFence()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
CompareAndSwap(volatile sys::cas_flag * ptr,sys::cas_flag new_value,sys::cas_flag old_value)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
AtomicIncrement(volatile sys::cas_flag * ptr)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
AtomicDecrement(volatile sys::cas_flag * ptr)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
AtomicAdd(volatile sys::cas_flag * ptr,sys::cas_flag val)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
AtomicMul(volatile sys::cas_flag * ptr,sys::cas_flag val)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
AtomicDiv(volatile sys::cas_flag * ptr,sys::cas_flag val)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 }
125