1 Fixes issues in atomic operations. 

     2 Will not send upstream. 

     3  

     4 --- a/toolkit/components/protobuf/src/google/protobuf/stubs/atomicops_internals_solaris.h	2015-11-03 11:34:16.000000000 +0100

     5 +++ b/toolkit/components/protobuf/src/google/protobuf/stubs/atomicops_internals_solaris.h	2015-11-10 04:19:53.044083000 +0100

     6 @@ -1,5 +1,4 @@

     7 -// Copyright 2014 Google Inc. All rights reserved.

     8 -// https://developers.google.com/protocol-buffers/

     9 +// Copyright 2013 Red Hat Inc.  All rights reserved.

    10  //

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

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

    13 @@ -11,7 +10,7 @@

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

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

    16  // distribution.

    17 -//     * Neither the name of Google Inc. nor the names of its

    18 +//     * Neither the name of Red Hat Inc. nor the names of its

    19  // contributors may be used to endorse or promote products derived from

    20  // this software without specific prior written permission.

    21  //

    22 @@ -29,10 +28,8 @@

    23  

    24  // This file is an internal atomic implementation, use atomicops.h instead.

    25  

    26 -#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_SPARC_GCC_H_

    27 -#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_SPARC_GCC_H_

    28 -

    29 -#include <atomic.h>

    30 +#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_GCC_H_

    31 +#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_GCC_H_

    32  

    33  namespace google {

    34  namespace protobuf {

    35 @@ -41,148 +38,100 @@

    36  inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,

    37                                           Atomic32 old_value,

    38                                           Atomic32 new_value) {

    39 -  return (Atomic32)atomic_cas_32((volatile uint32_t*)ptr, (uint32_t)old_value, (uint32_t)new_value);

    40 +  __atomic_compare_exchange_n(ptr, &old_value, new_value, true,

    41 +                              __ATOMIC_RELAXED, __ATOMIC_RELAXED);

    42 +  return old_value;

    43  }

    44  

    45  inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,

    46                                           Atomic32 new_value) {

    47 -  return (Atomic32)atomic_swap_32((volatile uint32_t*)ptr, (uint32_t)new_value);

    48 +  return __atomic_exchange_n(ptr, new_value, __ATOMIC_RELAXED);

    49  }

    50  

    51  inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,

    52                                            Atomic32 increment) {

    53 -  return (Atomic32)atomic_add_32_nv((volatile uint32_t*)ptr, (uint32_t)increment);

    54 -}

    55 -

    56 -inline void MemoryBarrier(void) {

    57 -	membar_producer();

    58 -	membar_consumer();

    59 +  return __atomic_add_fetch(ptr, increment, __ATOMIC_RELAXED);

    60  }

    61  

    62  inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,

    63                                          Atomic32 increment) {

    64 -  MemoryBarrier();

    65 -  Atomic32 ret = NoBarrier_AtomicIncrement(ptr, increment);

    66 -  MemoryBarrier();

    67 -

    68 -  return ret;

    69 +  return __atomic_add_fetch(ptr, increment, __ATOMIC_SEQ_CST);

    70  }

    71  

    72  inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,

    73                                         Atomic32 old_value,

    74                                         Atomic32 new_value) {

    75 -  Atomic32 ret = NoBarrier_CompareAndSwap(ptr, old_value, new_value);

    76 -  MemoryBarrier();

    77 -

    78 -  return ret;

    79 +  __atomic_compare_exchange(ptr, &old_value, &new_value, true,

    80 +                            __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE);

    81 +  return old_value;

    82  }

    83  

    84  inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,

    85                                         Atomic32 old_value,

    86                                         Atomic32 new_value) {

    87 -  MemoryBarrier();

    88 -  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);

    89 +  __atomic_compare_exchange_n(ptr, &old_value, new_value, true,

    90 +                              __ATOMIC_RELEASE, __ATOMIC_ACQUIRE);

    91 +  return old_value;

    92  }

    93  

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

    95 -  *ptr = value;

    96 +  __atomic_store_n(ptr, value, __ATOMIC_RELAXED);

    97 +}

    98 +

    99 +inline void MemoryBarrier() {

   100 +  __sync_synchronize();

   101  }

   102  

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

   104 -  *ptr = value;

   105 -  membar_producer();

   106 +  __atomic_store_n(ptr, value, __ATOMIC_SEQ_CST);

   107  }

   108  

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

   110 -  membar_consumer();

   111 -  *ptr = value;

   112 +  __atomic_store_n(ptr, value, __ATOMIC_RELEASE);

   113  }

   114  

   115  inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {

   116 -  return *ptr;

   117 +  return __atomic_load_n(ptr, __ATOMIC_RELAXED);

   118  }

   119  

   120  inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {

   121 -  Atomic32 val = *ptr;

   122 -  membar_consumer();

   123 -  return val;

   124 +  return __atomic_load_n(ptr, __ATOMIC_ACQUIRE);

   125  }

   126  

   127  inline Atomic32 Release_Load(volatile const Atomic32* ptr) {

   128 -  membar_producer();

   129 -  return *ptr;

   130 +  return __atomic_load_n(ptr, __ATOMIC_SEQ_CST);

   131  }

   132  

   133 -#ifdef GOOGLE_PROTOBUF_ARCH_64_BIT

   134 -inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,

   135 -                                         Atomic64 old_value,

   136 -                                         Atomic64 new_value) {

   137 -  return atomic_cas_64((volatile uint64_t*)ptr, (uint64_t)old_value, (uint64_t)new_value);

   138 -}

   139 +#ifdef __LP64__

   140  

   141 -inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value) {

   142 -  return atomic_swap_64((volatile uint64_t*)ptr, (uint64_t)new_value);

   143 -}

   144 -

   145 -inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment) {

   146 -  return atomic_add_64_nv((volatile uint64_t*)ptr, increment);

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

   148 +  __atomic_store_n(ptr, value, __ATOMIC_RELEASE);

   149  }

   150  

   151 -inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment) {

   152 -  MemoryBarrier();

   153 -  Atomic64 ret = atomic_add_64_nv((volatile uint64_t*)ptr, increment);

   154 -  MemoryBarrier();

   155 -  return ret;

   156 +inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {

   157 +  return __atomic_load_n(ptr, __ATOMIC_ACQUIRE);

   158  }

   159  

   160  inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,

   161                                         Atomic64 old_value,

   162                                         Atomic64 new_value) {

   163 -  Atomic64 ret = NoBarrier_CompareAndSwap(ptr, old_value, new_value);

   164 -  MemoryBarrier();

   165 -  return ret;

   166 +  __atomic_compare_exchange_n(ptr, &old_value, new_value, true,

   167 +                              __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE);

   168 +  return old_value;

   169  }

   170  

   171 -inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,

   172 +inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,

   173                                         Atomic64 old_value,

   174                                         Atomic64 new_value) {

   175 -  MemoryBarrier();

   176 -  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);

   177 -}

   178 -

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

   180 -  *ptr = value;

   181 -}

   182 -

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

   184 -  *ptr = value;

   185 -  membar_producer();

   186 +  __atomic_compare_exchange_n(ptr, &old_value, new_value, true,

   187 +                              __ATOMIC_RELAXED, __ATOMIC_RELAXED);

   188 +  return old_value;

   189  }

   190  

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

   192 -  membar_consumer();

   193 -  *ptr = value;

   194 -}

   195 -

   196 -inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {

   197 -  return *ptr;

   198 -}

   199 -

   200 -inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {

   201 -  Atomic64 ret = *ptr;

   202 -  membar_consumer();

   203 -  return ret;

   204 -}

   205 -

   206 -inline Atomic64 Release_Load(volatile const Atomic64* ptr) {

   207 -  membar_producer();

   208 -  return *ptr;

   209 -}

   210 -#endif

   211 +#endif // defined(__LP64__)

   212  

   213  }  // namespace internal

   214  }  // namespace protobuf

   215  }  // namespace google

   216  

   217 -#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_SPARC_GCC_H_

   218 -

   219 +#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_GCC_H_