iframe-proxy | Sunbelt Computer Software

History

223 lines (189 loc) · 7.11 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

// * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

// * Neither the name of Google Inc. nor the name Chromium Embedded

// Framework nor the names of its contributors may be used to endorse

// or promote products derived from this software without specific prior

// written permission.

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Do not include this header file directly. Use base/cef_atomicops.h

// instead.

#ifndef CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_MAC_H_

#define CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_MAC_H_

#include <libkern/OSAtomic.h>

namespace base {

namespace subtle {

inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,

Atomic32 old_value,

Atomic32 new_value) {

Atomic32 prev_value;

do {

if (OSAtomicCompareAndSwap32(old_value, new_value,

const_cast<Atomic32*>(ptr))) {

return old_value;

}

prev_value = *ptr;

} while (prev_value == old_value);

return prev_value;

}

inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,

Atomic32 new_value) {

Atomic32 old_value;

do {

old_value = *ptr;

} while (!OSAtomicCompareAndSwap32(old_value, new_value,

const_cast<Atomic32*>(ptr)));

return old_value;

}

inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,

Atomic32 increment) {

return OSAtomicAdd32(increment, const_cast<Atomic32*>(ptr));

}

inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,

Atomic32 increment) {

return OSAtomicAdd32Barrier(increment, const_cast<Atomic32*>(ptr));

}

inline void MemoryBarrier() {

OSMemoryBarrier();

}

inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,

Atomic32 old_value,

Atomic32 new_value) {

Atomic32 prev_value;

do {

if (OSAtomicCompareAndSwap32Barrier(old_value, new_value,

const_cast<Atomic32*>(ptr))) {

return old_value;

}

prev_value = *ptr;

} while (prev_value == old_value);

return prev_value;

}

inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,

Atomic32 old_value,

Atomic32 new_value) {

return Acquire_CompareAndSwap(ptr, old_value, new_value);

}

inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {

*ptr = value;

}

inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {

*ptr = value;

MemoryBarrier();

}

inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {

MemoryBarrier();

*ptr = value;

}

inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {

return *ptr;

}

inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {

Atomic32 value = *ptr;

MemoryBarrier();

return value;

}

inline Atomic32 Release_Load(volatile const Atomic32* ptr) {

MemoryBarrier();

return *ptr;

}

#ifdef __LP64__

// 64-bit implementation on 64-bit platform

inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,

Atomic64 old_value,

Atomic64 new_value) {

Atomic64 prev_value;

do {

if (OSAtomicCompareAndSwap64(old_value, new_value,

reinterpret_cast<volatile int64_t*>(ptr))) {

return old_value;

}

prev_value = *ptr;

} while (prev_value == old_value);

return prev_value;

}

inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,

Atomic64 new_value) {

Atomic64 old_value;

do {

old_value = *ptr;

} while (!OSAtomicCompareAndSwap64(old_value, new_value,

reinterpret_cast<volatile int64_t*>(ptr)));

return old_value;

}

inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,

Atomic64 increment) {

return OSAtomicAdd64(increment, reinterpret_cast<volatile int64_t*>(ptr));

}

inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,

Atomic64 increment) {

return OSAtomicAdd64Barrier(increment,

reinterpret_cast<volatile int64_t*>(ptr));

}

inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,

Atomic64 old_value,

Atomic64 new_value) {

Atomic64 prev_value;

do {

if (OSAtomicCompareAndSwap64Barrier(

old_value, new_value, reinterpret_cast<volatile int64_t*>(ptr))) {

return old_value;

}

prev_value = *ptr;

} while (prev_value == old_value);

return prev_value;

}

inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,

Atomic64 old_value,

Atomic64 new_value) {

// The lib kern interface does not distinguish between

// Acquire and Release memory barriers; they are equivalent.

return Acquire_CompareAndSwap(ptr, old_value, new_value);

}

inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {

*ptr = value;

}

inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {

*ptr = value;

MemoryBarrier();

}

inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {

MemoryBarrier();

*ptr = value;

}

inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {

return *ptr;

}

inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {

Atomic64 value = *ptr;

MemoryBarrier();

return value;

}

inline Atomic64 Release_Load(volatile const Atomic64* ptr) {

MemoryBarrier();

return *ptr;

}

#endif // defined(__LP64__)

} // namespace base::subtle

} // namespace base

#endif // CEF_INCLUDE_BASE_INTERNAL_CEF_ATOMICOPS_MAC_H_

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Sunbelt Computer Software

PL/B Language Development and Support

FilesExpand file tree

cef_atomicops_mac.h

Latest commit

History

cef_atomicops_mac.h

File metadata and controls