Atomics overhaul.

This merges and refactors SkAtomics.h and SkBarriers.h into SkAtomics.h and
some ports/ implementations. The major new feature is that we can express
memory orders explicitly rather than only through comments.

The porting layer is reduced to four template functions:
  - sk_atomic_load
  - sk_atomic_store
  - sk_atomic_fetch_add
  - sk_atomic_compare_exchange
From those four we can reconstruct all our previous sk_atomic_foo.

There are three ports:
  - SkAtomics_std:    uses C++11 <atomic>,             used with MSVC
  - SkAtomics_atomic: uses newer GCC/Clang intrinsics, used on not-MSVC where possible
  - SkAtomics_sync:   uses older GCC/Clang intrinsics, used where SkAtomics_atomic not supported

No public API changes.
TBR=reed@google.com

BUG=skia:

Review URL: https://codereview.chromium.org/896553002

1 files changed, 36 insertions, 0 deletions

diff --git a/include/ports/SkAtomics_std.h b/include/ports/SkAtomics_std.h
new file mode 100644
index 0000000000..f1fb0e2053
--- /dev/null
+++ b/include/ports/SkAtomics_std.h
@@ -0,0 +1,36 @@
+#ifndef SkAtomics_std_DEFINED
+#define SkAtomics_std_DEFINED
+
+// We try not to depend on the C++ standard library,
+// but these uses of <atomic> should all inline, so we don't feel to bad here.
+#include <atomic>
+
+template <typename T>
+T sk_atomic_load(const T* ptr, sk_memory_order mo) {
+    const std::atomic<T>* ap = reinterpret_cast<const std::atomic<T>*>(ptr);
+    return std::atomic_load_explicit(ap, (std::memory_order)mo);
+}
+
+template <typename T>
+void sk_atomic_store(T* ptr, T val, sk_memory_order mo) {
+    std::atomic<T>* ap = reinterpret_cast<std::atomic<T>*>(ptr);
+    return std::atomic_store_explicit(ap, val, (std::memory_order)mo);
+}
+
+template <typename T>
+T sk_atomic_fetch_add(T* ptr, T val, sk_memory_order mo) {
+    std::atomic<T>* ap = reinterpret_cast<std::atomic<T>*>(ptr);
+    return std::atomic_fetch_add_explicit(ap, val, (std::memory_order)mo);
+}
+
+template <typename T>
+bool sk_atomic_compare_exchange(T* ptr, T* expected, T desired,
+                                sk_memory_order success,
+                                sk_memory_order failure) {
+    std::atomic<T>* ap = reinterpret_cast<std::atomic<T>*>(ptr);
+    return std::atomic_compare_exchange_strong_explicit(ap, expected, desired,
+                                                        (std::memory_order)success,
+                                                        (std::memory_order)failure);
+}
+
+#endif//SkAtomics_std_DEFINED