Dep/protobuf: Backport https://github.com/protocolbuffers/protobuf/pull/2337 to our embedded version

5 files changed, 596 insertions, 74 deletions

diff --git a/dep/protobuf/backport_protobuf_pr_2337_for_macos.diff b/dep/protobuf/backport_protobuf_pr_2337_for_macos.diff
new file mode 100644
index 00000000000..bfbece4965c
--- /dev/null
+++ b/dep/protobuf/backport_protobuf_pr_2337_for_macos.diff
@@ -0,0 +1,356 @@
+diff --git a/dep/protobuf/src/google/protobuf/descriptor.h b/dep/protobuf/src/google/protobuf/descriptor.h
+index 68013f8ee4..6f52b767b2 100644
+--- a/dep/protobuf/src/google/protobuf/descriptor.h
++++ b/dep/protobuf/src/google/protobuf/descriptor.h
+@@ -59,6 +59,10 @@
+ #include <vector>
+ #include <google/protobuf/stubs/common.h>
+ 
++// TYPE_BOOL is defined in the MacOS's ConditionalMacros.h.
++#ifdef TYPE_BOOL
++#undef TYPE_BOOL
++#endif  // TYPE_BOOL
+ 
+ namespace google {
+ namespace protobuf {
+diff --git a/dep/protobuf/src/google/protobuf/stubs/atomicops.h b/dep/protobuf/src/google/protobuf/stubs/atomicops.h
+index b1336e36b9..5bd3a1c23e 100644
+--- a/dep/protobuf/src/google/protobuf/stubs/atomicops.h
++++ b/dep/protobuf/src/google/protobuf/stubs/atomicops.h
+@@ -181,7 +181,11 @@ GOOGLE_PROTOBUF_ATOMICOPS_ERROR
+ 
+ // Apple.
+ #elif defined(GOOGLE_PROTOBUF_OS_APPLE)
++#if __has_feature(cxx_atomic) || _GNUC_VER >= 407
++#include <google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h>
++#else  // __has_feature(cxx_atomic) || _GNUC_VER >= 407
+ #include <google/protobuf/stubs/atomicops_internals_macosx.h>
++#endif  // __has_feature(cxx_atomic) || _GNUC_VER >= 407
+ 
+ // GCC.
+ #elif defined(__GNUC__)
+@@ -196,7 +200,7 @@ GOOGLE_PROTOBUF_ATOMICOPS_ERROR
+ #elif defined(GOOGLE_PROTOBUF_ARCH_MIPS) || defined(GOOGLE_PROTOBUF_ARCH_MIPS64)
+ #include <google/protobuf/stubs/atomicops_internals_mips_gcc.h>
+ #elif defined(__native_client__)
+-#include <google/protobuf/stubs/atomicops_internals_pnacl.h>
++#include <google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h>
+ #elif (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4))
+ #include <google/protobuf/stubs/atomicops_internals_generic_gcc.h>
+ #elif defined(__clang__)
+diff --git a/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h b/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h
+new file mode 100644
+index 0000000000..7bc584eb21
+--- /dev/null
++++ b/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h
+@@ -0,0 +1,231 @@
++// Protocol Buffers - Google's data interchange format
++// Copyright 2012 Google Inc.  All rights reserved.
++// https://developers.google.com/protocol-buffers/
++//
++// 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 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.
++
++// This file is an internal atomic implementation, use atomicops.h instead.
++
++#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_C11_ATOMIC_H_
++#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_C11_ATOMIC_H_
++
++#include <atomic>
++
++namespace google {
++namespace protobuf {
++namespace internal {
++
++// This implementation is transitional and maintains the original API for
++// atomicops.h. This requires casting memory locations to the atomic types, and
++// assumes that the API and the C++11 implementation are layout-compatible,
++// which isn't true for all implementations or hardware platforms. The static
++// assertion should detect this issue, were it to fire then this header
++// shouldn't be used.
++//
++// TODO(jfb) If this header manages to stay committed then the API should be
++//           modified, and all call sites updated.
++typedef volatile std::atomic<Atomic32>* AtomicLocation32;
++static_assert(sizeof(*(AtomicLocation32) nullptr) == sizeof(Atomic32),
++              "incompatible 32-bit atomic layout");
++
++inline void MemoryBarrier() {
++#if defined(__GLIBCXX__)
++  // Work around libstdc++ bug 51038 where atomic_thread_fence was declared but
++  // not defined, leading to the linker complaining about undefined references.
++  __atomic_thread_fence(std::memory_order_seq_cst);
++#else
++  std::atomic_thread_fence(std::memory_order_seq_cst);
++#endif
++}
++
++inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
++                                         Atomic32 old_value,
++                                         Atomic32 new_value) {
++  ((AtomicLocation32)ptr)
++      ->compare_exchange_strong(old_value,
++                                new_value,
++                                std::memory_order_relaxed,
++                                std::memory_order_relaxed);
++  return old_value;
++}
++
++inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
++                                         Atomic32 new_value) {
++  return ((AtomicLocation32)ptr)
++      ->exchange(new_value, std::memory_order_relaxed);
++}
++
++inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
++                                          Atomic32 increment) {
++  return increment +
++         ((AtomicLocation32)ptr)
++             ->fetch_add(increment, std::memory_order_relaxed);
++}
++
++inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
++                                        Atomic32 increment) {
++  return increment + ((AtomicLocation32)ptr)->fetch_add(increment);
++}
++
++inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
++                                       Atomic32 old_value,
++                                       Atomic32 new_value) {
++  ((AtomicLocation32)ptr)
++      ->compare_exchange_strong(old_value,
++                                new_value,
++                                std::memory_order_acquire,
++                                std::memory_order_acquire);
++  return old_value;
++}
++
++inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
++                                       Atomic32 old_value,
++                                       Atomic32 new_value) {
++  ((AtomicLocation32)ptr)
++      ->compare_exchange_strong(old_value,
++                                new_value,
++                                std::memory_order_release,
++                                std::memory_order_relaxed);
++  return old_value;
++}
++
++inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
++  ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
++}
++
++inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
++  ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
++  MemoryBarrier();
++}
++
++inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
++  ((AtomicLocation32)ptr)->store(value, std::memory_order_release);
++}
++
++inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
++  return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
++}
++
++inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
++  return ((AtomicLocation32)ptr)->load(std::memory_order_acquire);
++}
++
++inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
++  MemoryBarrier();
++  return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
++}
++
++#if defined(GOOGLE_PROTOBUF_ARCH_64_BIT)
++
++typedef volatile std::atomic<Atomic64>* AtomicLocation64;
++static_assert(sizeof(*(AtomicLocation64) nullptr) == sizeof(Atomic64),
++              "incompatible 64-bit atomic layout");
++
++inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
++                                         Atomic64 old_value,
++                                         Atomic64 new_value) {
++  ((AtomicLocation64)ptr)
++      ->compare_exchange_strong(old_value,
++                                new_value,
++                                std::memory_order_relaxed,
++                                std::memory_order_relaxed);
++  return old_value;
++}
++
++inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
++                                         Atomic64 new_value) {
++  return ((AtomicLocation64)ptr)
++      ->exchange(new_value, std::memory_order_relaxed);
++}
++
++inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
++                                          Atomic64 increment) {
++  return increment +
++         ((AtomicLocation64)ptr)
++             ->fetch_add(increment, std::memory_order_relaxed);
++}
++
++inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
++                                        Atomic64 increment) {
++  return increment + ((AtomicLocation64)ptr)->fetch_add(increment);
++}
++
++inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
++                                       Atomic64 old_value,
++                                       Atomic64 new_value) {
++  ((AtomicLocation64)ptr)
++      ->compare_exchange_strong(old_value,
++                                new_value,
++                                std::memory_order_acquire,
++                                std::memory_order_acquire);
++  return old_value;
++}
++
++inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
++                                       Atomic64 old_value,
++                                       Atomic64 new_value) {
++  ((AtomicLocation64)ptr)
++      ->compare_exchange_strong(old_value,
++                                new_value,
++                                std::memory_order_release,
++                                std::memory_order_relaxed);
++  return old_value;
++}
++
++inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
++  ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
++}
++
++inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
++  ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
++  MemoryBarrier();
++}
++
++inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
++  ((AtomicLocation64)ptr)->store(value, std::memory_order_release);
++}
++
++inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
++  return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
++}
++
++inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
++  return ((AtomicLocation64)ptr)->load(std::memory_order_acquire);
++}
++
++inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
++  MemoryBarrier();
++  return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
++}
++
++#endif  // defined(GOOGLE_PROTOBUF_ARCH_64_BIT)
++
++}  // namespace internal
++}  // namespace protobuf
++}  // namespace google
++
++#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_C11_ATOMIC_H_
+diff --git a/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_pnacl.h b/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_pnacl.h
+deleted file mode 100644
+index b10ac02c40..0000000000
+--- a/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_pnacl.h
++++ /dev/null
+@@ -1,73 +0,0 @@
+-// Protocol Buffers - Google's data interchange format
+-// Copyright 2012 Google Inc.  All rights reserved.
+-// https://developers.google.com/protocol-buffers/
+-//
+-// 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 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.
+-
+-// This file is an internal atomic implementation, use atomicops.h instead.
+-
+-#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_PNACL_H_
+-#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_PNACL_H_
+-
+-namespace google {
+-namespace protobuf {
+-namespace internal {
+-
+-inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+-                                         Atomic32 old_value,
+-                                         Atomic32 new_value) {
+-  return __sync_val_compare_and_swap(ptr, old_value, new_value);
+-}
+-
+-inline void MemoryBarrier() {
+-  __sync_synchronize();
+-}
+-
+-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+-                                       Atomic32 old_value,
+-                                       Atomic32 new_value) {
+-  Atomic32 ret = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+-  MemoryBarrier();
+-  return ret;
+-}
+-
+-inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+-  MemoryBarrier();
+-  *ptr = value;
+-}
+-
+-inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+-  Atomic32 value = *ptr;
+-  MemoryBarrier();
+-  return value;
+-}
+-
+-}  // namespace internal
+-}  // namespace protobuf
+-}  // namespace google
+-
+-#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_PNACL_H_
diff --git a/dep/protobuf/src/google/protobuf/descriptor.h b/dep/protobuf/src/google/protobuf/descriptor.h
index 68013f8ee41..6f52b767b2a 100644
--- a/dep/protobuf/src/google/protobuf/descriptor.h
+++ b/dep/protobuf/src/google/protobuf/descriptor.h
@@ -59,6 +59,10 @@
 #include <vector>
 #include <google/protobuf/stubs/common.h>
 
+// TYPE_BOOL is defined in the MacOS's ConditionalMacros.h.
+#ifdef TYPE_BOOL
+#undef TYPE_BOOL
+#endif  // TYPE_BOOL
 
 namespace google {
 namespace protobuf {
diff --git a/dep/protobuf/src/google/protobuf/stubs/atomicops.h b/dep/protobuf/src/google/protobuf/stubs/atomicops.h
index b1336e36b93..5bd3a1c23e2 100644
--- a/dep/protobuf/src/google/protobuf/stubs/atomicops.h
+++ b/dep/protobuf/src/google/protobuf/stubs/atomicops.h
@@ -181,7 +181,11 @@ GOOGLE_PROTOBUF_ATOMICOPS_ERROR
 
 // Apple.
 #elif defined(GOOGLE_PROTOBUF_OS_APPLE)
+#if __has_feature(cxx_atomic) || _GNUC_VER >= 407
+#include <google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h>
+#else  // __has_feature(cxx_atomic) || _GNUC_VER >= 407
 #include <google/protobuf/stubs/atomicops_internals_macosx.h>
+#endif  // __has_feature(cxx_atomic) || _GNUC_VER >= 407
 
 // GCC.
 #elif defined(__GNUC__)
@@ -196,7 +200,7 @@ GOOGLE_PROTOBUF_ATOMICOPS_ERROR
 #elif defined(GOOGLE_PROTOBUF_ARCH_MIPS) || defined(GOOGLE_PROTOBUF_ARCH_MIPS64)
 #include <google/protobuf/stubs/atomicops_internals_mips_gcc.h>
 #elif defined(__native_client__)
-#include <google/protobuf/stubs/atomicops_internals_pnacl.h>
+#include <google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h>
 #elif (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4))
 #include <google/protobuf/stubs/atomicops_internals_generic_gcc.h>
 #elif defined(__clang__)
diff --git a/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h b/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h
new file mode 100644
index 00000000000..7bc584eb211
--- /dev/null
+++ b/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h
@@ -0,0 +1,231 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// 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 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.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_C11_ATOMIC_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_C11_ATOMIC_H_
+
+#include <atomic>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// This implementation is transitional and maintains the original API for
+// atomicops.h. This requires casting memory locations to the atomic types, and
+// assumes that the API and the C++11 implementation are layout-compatible,
+// which isn't true for all implementations or hardware platforms. The static
+// assertion should detect this issue, were it to fire then this header
+// shouldn't be used.
+//
+// TODO(jfb) If this header manages to stay committed then the API should be
+//           modified, and all call sites updated.
+typedef volatile std::atomic<Atomic32>* AtomicLocation32;
+static_assert(sizeof(*(AtomicLocation32) nullptr) == sizeof(Atomic32),
+              "incompatible 32-bit atomic layout");
+
+inline void MemoryBarrier() {
+#if defined(__GLIBCXX__)
+  // Work around libstdc++ bug 51038 where atomic_thread_fence was declared but
+  // not defined, leading to the linker complaining about undefined references.
+  __atomic_thread_fence(std::memory_order_seq_cst);
+#else
+  std::atomic_thread_fence(std::memory_order_seq_cst);
+#endif
+}
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  ((AtomicLocation32)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_relaxed,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  return ((AtomicLocation32)ptr)
+      ->exchange(new_value, std::memory_order_relaxed);
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  return increment +
+         ((AtomicLocation32)ptr)
+             ->fetch_add(increment, std::memory_order_relaxed);
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  return increment + ((AtomicLocation32)ptr)->fetch_add(increment);
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  ((AtomicLocation32)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_acquire,
+                                std::memory_order_acquire);
+  return old_value;
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  ((AtomicLocation32)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_release,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
+  MemoryBarrier();
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  ((AtomicLocation32)ptr)->store(value, std::memory_order_release);
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  return ((AtomicLocation32)ptr)->load(std::memory_order_acquire);
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  MemoryBarrier();
+  return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
+}
+
+#if defined(GOOGLE_PROTOBUF_ARCH_64_BIT)
+
+typedef volatile std::atomic<Atomic64>* AtomicLocation64;
+static_assert(sizeof(*(AtomicLocation64) nullptr) == sizeof(Atomic64),
+              "incompatible 64-bit atomic layout");
+
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                         Atomic64 old_value,
+                                         Atomic64 new_value) {
+  ((AtomicLocation64)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_relaxed,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+                                         Atomic64 new_value) {
+  return ((AtomicLocation64)ptr)
+      ->exchange(new_value, std::memory_order_relaxed);
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+                                          Atomic64 increment) {
+  return increment +
+         ((AtomicLocation64)ptr)
+             ->fetch_add(increment, std::memory_order_relaxed);
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
+                                        Atomic64 increment) {
+  return increment + ((AtomicLocation64)ptr)->fetch_add(increment);
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  ((AtomicLocation64)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_acquire,
+                                std::memory_order_acquire);
+  return old_value;
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  ((AtomicLocation64)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_release,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+  ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+  ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
+  MemoryBarrier();
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+  ((AtomicLocation64)ptr)->store(value, std::memory_order_release);
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+  return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+  return ((AtomicLocation64)ptr)->load(std::memory_order_acquire);
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+  MemoryBarrier();
+  return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
+}
+
+#endif  // defined(GOOGLE_PROTOBUF_ARCH_64_BIT)
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_C11_ATOMIC_H_
diff --git a/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_pnacl.h b/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_pnacl.h
deleted file mode 100644
index b10ac02c407..00000000000
--- a/dep/protobuf/src/google/protobuf/stubs/atomicops_internals_pnacl.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2012 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// 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 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.
-
-// This file is an internal atomic implementation, use atomicops.h instead.
-
-#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_PNACL_H_
-#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_PNACL_H_
-
-namespace google {
-namespace protobuf {
-namespace internal {
-
-inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                         Atomic32 old_value,
-                                         Atomic32 new_value) {
-  return __sync_val_compare_and_swap(ptr, old_value, new_value);
-}
-
-inline void MemoryBarrier() {
-  __sync_synchronize();
-}
-
-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  Atomic32 ret = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
-  MemoryBarrier();
-  return ret;
-}
-
-inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
-  MemoryBarrier();
-  *ptr = value;
-}
-
-inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
-  Atomic32 value = *ptr;
-  MemoryBarrier();
-  return value;
-}
-
-}  // namespace internal
-}  // namespace protobuf
-}  // namespace google
-
-#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_PNACL_H_