CDRIVER-4229 emulate int32 and int atomic operations on zSeries (#897)

Author: kevinAlbs

src/libbson/src/bson/bson-atomic.c

@@ -48,40 +48,40 @@ bson_memory_barrier (void)
 }
 
 /**
- * 32-bit x86 does not support 64-bit atomic integer operations.
+ * Some platforms do not support compiler intrinsics for atomic operations.
  * We emulate that here using a spin lock and regular arithmetic operations
  */
-static int8_t g64bitAtomicLock = 0;
+static int8_t gEmulAtomicLock = 0;
 
 static void
-_lock_64bit_atomic ()
+_lock_emul_atomic ()
 {
    int i;
    if (bson_atomic_int8_compare_exchange_weak (
-          &g64bitAtomicLock, 0, 1, bson_memory_order_acquire) == 0) {
+          &gEmulAtomicLock, 0, 1, bson_memory_order_acquire) == 0) {
       /* Successfully took the spinlock */
       return;
    }
    /* Failed. Try taking ten more times, then begin sleeping. */
    for (i = 0; i < 10; ++i) {
       if (bson_atomic_int8_compare_exchange_weak (
-             &g64bitAtomicLock, 0, 1, bson_memory_order_acquire) == 0) {
+             &gEmulAtomicLock, 0, 1, bson_memory_order_acquire) == 0) {
          /* Succeeded in taking the lock */
          return;
       }
    }
    /* Still don't have the lock. Spin and yield */
    while (bson_atomic_int8_compare_exchange_weak (
-             &g64bitAtomicLock, 0, 1, bson_memory_order_acquire) != 0) {
+             &gEmulAtomicLock, 0, 1, bson_memory_order_acquire) != 0) {
       bson_thrd_yield ();
    }
 }
 
 static void
-_unlock_64bit_atomic ()
+_unlock_emul_atomic ()
 {
    int64_t rv = bson_atomic_int8_exchange (
-      &g64bitAtomicLock, 0, bson_memory_order_release);
+      &gEmulAtomicLock, 0, bson_memory_order_release);
    BSON_ASSERT (rv == 1 && "Released atomic lock while not holding it");
 }
 
@@ -91,10 +91,10 @@ _bson_emul_atomic_int64_fetch_add (volatile int64_t *p,
                                    enum bson_memory_order _unused)
 {
    int64_t ret;
-   _lock_64bit_atomic ();
+   _lock_emul_atomic ();
    ret = *p;
    *p += n;
-   _unlock_64bit_atomic ();
+   _unlock_emul_atomic ();
    return ret;
 }
 
@@ -104,10 +104,10 @@ _bson_emul_atomic_int64_exchange (volatile int64_t *p,
                                   enum bson_memory_order _unused)
 {
    int64_t ret;
-   _lock_64bit_atomic ();
+   _lock_emul_atomic ();
    ret = *p;
    *p = n;
-   _unlock_64bit_atomic ();
+   _unlock_emul_atomic ();
    return ret;
 }
 
@@ -118,12 +118,12 @@ _bson_emul_atomic_int64_compare_exchange_strong (volatile int64_t *p,
                                                  enum bson_memory_order _unused)
 {
    int64_t ret;
-   _lock_64bit_atomic ();
+   _lock_emul_atomic ();
    ret = *p;
    if (ret == expect_value) {
       *p = new_value;
    }
-   _unlock_64bit_atomic ();
+   _unlock_emul_atomic ();
    return ret;
 }
 
@@ -137,3 +137,111 @@ _bson_emul_atomic_int64_compare_exchange_weak (volatile int64_t *p,
    return _bson_emul_atomic_int64_compare_exchange_strong (
       p, expect_value, new_value, order);
 }
+
+
+int32_t
+_bson_emul_atomic_int32_fetch_add (volatile int32_t *p,
+                                   int32_t n,
+                                   enum bson_memory_order _unused)
+{
+   int32_t ret;
+   _lock_emul_atomic ();
+   ret = *p;
+   *p += n;
+   _unlock_emul_atomic ();
+   return ret;
+}
+
+int32_t
+_bson_emul_atomic_int32_exchange (volatile int32_t *p,
+                                  int32_t n,
+                                  enum bson_memory_order _unused)
+{
+   int32_t ret;
+   _lock_emul_atomic ();
+   ret = *p;
+   *p = n;
+   _unlock_emul_atomic ();
+   return ret;
+}
+
+int32_t
+_bson_emul_atomic_int32_compare_exchange_strong (volatile int32_t *p,
+                                                 int32_t expect_value,
+                                                 int32_t new_value,
+                                                 enum bson_memory_order _unused)
+{
+   int32_t ret;
+   _lock_emul_atomic ();
+   ret = *p;
+   if (ret == expect_value) {
+      *p = new_value;
+   }
+   _unlock_emul_atomic ();
+   return ret;
+}
+
+int32_t
+_bson_emul_atomic_int32_compare_exchange_weak (volatile int32_t *p,
+                                               int32_t expect_value,
+                                               int32_t new_value,
+                                               enum bson_memory_order order)
+{
+   /* We're emulating. We can't do a weak version. */
+   return _bson_emul_atomic_int32_compare_exchange_strong (
+      p, expect_value, new_value, order);
+}
+
+
+int
+_bson_emul_atomic_int_fetch_add (volatile int *p,
+                                   int n,
+                                   enum bson_memory_order _unused)
+{
+   int ret;
+   _lock_emul_atomic ();
+   ret = *p;
+   *p += n;
+   _unlock_emul_atomic ();
+   return ret;
+}
+
+int
+_bson_emul_atomic_int_exchange (volatile int *p,
+                                  int n,
+                                  enum bson_memory_order _unused)
+{
+   int ret;
+   _lock_emul_atomic ();
+   ret = *p;
+   *p = n;
+   _unlock_emul_atomic ();
+   return ret;
+}
+
+int
+_bson_emul_atomic_int_compare_exchange_strong (volatile int *p,
+                                                 int expect_value,
+                                                 int new_value,
+                                                 enum bson_memory_order _unused)
+{
+   int ret;
+   _lock_emul_atomic ();
+   ret = *p;
+   if (ret == expect_value) {
+      *p = new_value;
+   }
+   _unlock_emul_atomic ();
+   return ret;
+}
+
+int
+_bson_emul_atomic_int_compare_exchange_weak (volatile int *p,
+                                               int expect_value,
+                                               int new_value,
+                                               enum bson_memory_order order)
+{
+   /* We're emulating. We can't do a weak version. */
+   return _bson_emul_atomic_int_compare_exchange_strong (
+      p, expect_value, new_value, order);
+}