passenger 5.0.24 → 5.0.25

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/cas64strong.hpp

@@ -1,443 +0,0 @@
-#ifndef BOOST_ATOMIC_DETAIL_CAS64STRONG_HPP
-#define BOOST_ATOMIC_DETAIL_CAS64STRONG_HPP
-
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-//
-//  Copyright (c) 2011 Helge Bahmann
-//  Copyright (c) 2013 Tim Blechmann
-
-// Build 64-bit atomic operation from platform_cmpxchg64_strong
-// primitive. It is assumed that 64-bit loads/stores are not
-// atomic, so they are funnelled through cmpxchg as well.
-
-#include <cstddef>
-#include <boost/cstdint.hpp>
-#include <boost/memory_order.hpp>
-#include <boost/atomic/detail/config.hpp>
-#include <boost/atomic/detail/base.hpp>
-
-#ifdef BOOST_ATOMIC_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-namespace boost {
-namespace atomics {
-namespace detail {
-
-/* integral types */
-
-template<typename T, bool Sign>
-class base_atomic<T, int, 8, Sign>
-{
-    typedef base_atomic this_type;
-    typedef T value_type;
-    typedef T difference_type;
-public:
-    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
-    base_atomic(void) {}
-
-    void
-    store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        platform_fence_before_store(order);
-        platform_store64(v, &v_);
-        platform_fence_after_store(order);
-    }
-
-    value_type
-    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
-    {
-        value_type v = platform_load64(&v_);
-        platform_fence_after_load(order);
-        return v;
-    }
-
-    value_type
-    exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, v, order, memory_order_relaxed));
-        return original;
-    }
-
-    bool
-    compare_exchange_weak(
-        value_type & expected,
-        value_type desired,
-        memory_order success_order,
-        memory_order failure_order) volatile BOOST_NOEXCEPT
-    {
-        return compare_exchange_strong(expected, desired, success_order, failure_order);
-    }
-
-    bool
-    compare_exchange_strong(
-        value_type & expected,
-        value_type desired,
-        memory_order success_order,
-        memory_order failure_order) volatile BOOST_NOEXCEPT
-    {
-        platform_fence_before(success_order);
-
-        bool success = platform_cmpxchg64_strong(expected, desired, &v_);
-
-        if (success) {
-            platform_fence_after(success_order);
-        } else {
-            platform_fence_after(failure_order);
-        }
-
-        return success;
-    }
-
-    value_type
-    fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed));
-        return original;
-    }
-
-    value_type
-    fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed));
-        return original;
-    }
-
-    value_type
-    fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, original & v, order, memory_order_relaxed));
-        return original;
-    }
-
-    value_type
-    fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, original | v, order, memory_order_relaxed));
-        return original;
-    }
-
-    value_type
-    fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, original ^ v, order, memory_order_relaxed));
-        return original;
-    }
-
-    bool
-    is_lock_free(void) const volatile BOOST_NOEXCEPT
-    {
-        return true;
-    }
-
-    BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS
-private:
-    base_atomic(const base_atomic &) /* = delete */ ;
-    void operator=(const base_atomic &) /* = delete */ ;
-    value_type v_;
-};
-
-/* pointer types */
-
-template<bool Sign>
-class base_atomic<void *, void *, 8, Sign>
-{
-    typedef base_atomic this_type;
-    typedef void * value_type;
-    typedef ptrdiff_t difference_type;
-public:
-    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
-    base_atomic(void) {}
-
-    void
-    store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        platform_fence_before_store(order);
-        platform_store64(v, &v_);
-        platform_fence_after_store(order);
-    }
-
-    value_type
-    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
-    {
-        value_type v = platform_load64(&v_);
-        platform_fence_after_load(order);
-        return v;
-    }
-
-    value_type
-    exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, v, order, memory_order_relaxed));
-        return original;
-    }
-
-    bool
-    compare_exchange_weak(
-        value_type & expected,
-        value_type desired,
-        memory_order success_order,
-        memory_order failure_order) volatile BOOST_NOEXCEPT
-    {
-        return compare_exchange_strong(expected, desired, success_order, failure_order);
-    }
-
-    bool
-    compare_exchange_strong(
-        value_type & expected,
-        value_type desired,
-        memory_order success_order,
-        memory_order failure_order) volatile BOOST_NOEXCEPT
-    {
-        platform_fence_before(success_order);
-
-        bool success = platform_cmpxchg64_strong(expected, desired, &v_);
-
-        if (success) {
-            platform_fence_after(success_order);
-        } else {
-            platform_fence_after(failure_order);
-        }
-
-        return success;
-    }
-
-    value_type
-    fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, (char*)original + v, order, memory_order_relaxed));
-        return original;
-    }
-
-    value_type
-    fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, (char*)original - v, order, memory_order_relaxed));
-        return original;
-    }
-
-    bool
-    is_lock_free(void) const volatile BOOST_NOEXCEPT
-    {
-        return true;
-    }
-
-    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
-private:
-    base_atomic(const base_atomic &) /* = delete */ ;
-    void operator=(const base_atomic &) /* = delete */ ;
-    value_type v_;
-};
-
-template<typename T, bool Sign>
-class base_atomic<T *, void *, 8, Sign>
-{
-    typedef base_atomic this_type;
-    typedef T * value_type;
-    typedef ptrdiff_t difference_type;
-public:
-    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
-    base_atomic(void) {}
-
-    void
-    store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        platform_fence_before_store(order);
-        platform_store64(v, &v_);
-        platform_fence_after_store(order);
-    }
-
-    value_type
-    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
-    {
-        value_type v = platform_load64(&v_);
-        platform_fence_after_load(order);
-        return v;
-    }
-
-    value_type
-    exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, v, order, memory_order_relaxed));
-        return original;
-    }
-
-    bool
-    compare_exchange_weak(
-        value_type & expected,
-        value_type desired,
-        memory_order success_order,
-        memory_order failure_order) volatile BOOST_NOEXCEPT
-    {
-        return compare_exchange_strong(expected, desired, success_order, failure_order);
-    }
-
-    bool
-    compare_exchange_strong(
-        value_type & expected,
-        value_type desired,
-        memory_order success_order,
-        memory_order failure_order) volatile BOOST_NOEXCEPT
-    {
-        platform_fence_before(success_order);
-
-        bool success = platform_cmpxchg64_strong(expected, desired, &v_);
-
-        if (success) {
-            platform_fence_after(success_order);
-        } else {
-            platform_fence_after(failure_order);
-        }
-
-        return success;
-    }
-
-    value_type
-    fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed));
-        return original;
-    }
-
-    value_type
-    fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed));
-        return original;
-    }
-
-    bool
-    is_lock_free(void) const volatile BOOST_NOEXCEPT
-    {
-        return true;
-    }
-
-    BOOST_ATOMIC_DECLARE_POINTER_OPERATORS
-private:
-    base_atomic(const base_atomic &) /* = delete */ ;
-    void operator=(const base_atomic &) /* = delete */ ;
-    value_type v_;
-};
-
-/* generic types */
-
-template<typename T, bool Sign>
-class base_atomic<T, void, 8, Sign>
-{
-    typedef base_atomic this_type;
-    typedef T value_type;
-    typedef uint64_t storage_type;
-public:
-    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
-    {
-        memcpy(&v_, &v, sizeof(value_type));
-    }
-    base_atomic(void) {}
-
-    void
-    store(value_type const& value, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        storage_type value_s = 0;
-        memcpy(&value_s, &value, sizeof(value_type));
-        platform_fence_before_store(order);
-        platform_store64(value_s, &v_);
-        platform_fence_after_store(order);
-    }
-
-    value_type
-    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
-    {
-        storage_type value_s = platform_load64(&v_);
-        platform_fence_after_load(order);
-        value_type value;
-        memcpy(&value, &value_s, sizeof(value_type));
-        return value;
-    }
-
-    value_type
-    exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        value_type original = load(memory_order_relaxed);
-        do {
-        } while (!compare_exchange_weak(original, v, order, memory_order_relaxed));
-        return original;
-    }
-
-    bool
-    compare_exchange_weak(
-        value_type & expected,
-        value_type const& desired,
-        memory_order success_order,
-        memory_order failure_order) volatile BOOST_NOEXCEPT
-    {
-        return compare_exchange_strong(expected, desired, success_order, failure_order);
-    }
-
-    bool
-    compare_exchange_strong(
-        value_type & expected,
-        value_type const& desired,
-        memory_order success_order,
-        memory_order failure_order) volatile BOOST_NOEXCEPT
-    {
-        storage_type expected_s = 0, desired_s = 0;
-        memcpy(&expected_s, &expected, sizeof(value_type));
-        memcpy(&desired_s, &desired, sizeof(value_type));
-
-        platform_fence_before(success_order);
-        bool success = platform_cmpxchg64_strong(expected_s, desired_s, &v_);
-
-        if (success) {
-            platform_fence_after(success_order);
-        } else {
-            platform_fence_after(failure_order);
-            memcpy(&expected, &expected_s, sizeof(value_type));
-        }
-
-        return success;
-    }
-
-    bool
-    is_lock_free(void) const volatile BOOST_NOEXCEPT
-    {
-        return true;
-    }
-
-    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
-private:
-    base_atomic(const base_atomic &) /* = delete */ ;
-    void operator=(const base_atomic &) /* = delete */ ;
-    storage_type v_;
-};
-
-}
-}
-}
-
-#endif

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/gcc-alpha.hpp

@@ -1,368 +0,0 @@
-#ifndef BOOST_ATOMIC_DETAIL_GCC_ALPHA_HPP
-#define BOOST_ATOMIC_DETAIL_GCC_ALPHA_HPP
-
-//  Copyright (c) 2009 Helge Bahmann
-//  Copyright (c) 2013 Tim Blechmann
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/atomic/detail/config.hpp>
-#include <boost/atomic/detail/base.hpp>
-#include <boost/atomic/detail/builder.hpp>
-
-#ifdef BOOST_ATOMIC_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-/*
-  Refer to http://h71000.www7.hp.com/doc/82final/5601/5601pro_004.html
-  (HP OpenVMS systems documentation) and the alpha reference manual.
- */
-
-/*
-    NB: The most natural thing would be to write the increment/decrement
-    operators along the following lines:
-
-    __asm__ __volatile__(
-        "1: ldl_l %0,%1 \n"
-        "addl %0,1,%0 \n"
-        "stl_c %0,%1 \n"
-        "beq %0,1b\n"
-        : "=&b" (tmp)
-        : "m" (value)
-        : "cc"
-    );
-
-    However according to the comments on the HP website and matching
-    comments in the Linux kernel sources this defies branch prediction,
-    as the cpu assumes that backward branches are always taken; so
-    instead copy the trick from the Linux kernel, introduce a forward
-    branch and back again.
-
-    I have, however, had a hard time measuring the difference between
-    the two versions in microbenchmarks -- I am leaving it in nevertheless
-    as it apparently does not hurt either.
-*/
-
-namespace boost {
-namespace atomics {
-namespace detail {
-
-inline void fence_before(memory_order order)
-{
-    switch(order) {
-        case memory_order_consume:
-        case memory_order_release:
-        case memory_order_acq_rel:
-        case memory_order_seq_cst:
-            __asm__ __volatile__ ("mb" ::: "memory");
-        default:;
-    }
-}
-
-inline void fence_after(memory_order order)
-{
-    switch(order) {
-        case memory_order_acquire:
-        case memory_order_acq_rel:
-        case memory_order_seq_cst:
-            __asm__ __volatile__ ("mb" ::: "memory");
-        default:;
-    }
-}
-
-template<>
-inline void platform_atomic_thread_fence(memory_order order)
-{
-    switch(order) {
-        case memory_order_acquire:
-        case memory_order_consume:
-        case memory_order_release:
-        case memory_order_acq_rel:
-        case memory_order_seq_cst:
-            __asm__ __volatile__ ("mb" ::: "memory");
-        default:;
-    }
-}
-
-template<typename T>
-class atomic_alpha_32
-{
-public:
-    typedef T integral_type;
-    BOOST_CONSTEXPR atomic_alpha_32(T v) BOOST_NOEXCEPT: i(v) {}
-    atomic_alpha_32() {}
-    T load(memory_order order=memory_order_seq_cst) const volatile BOOST_NOEXCEPT
-    {
-        T v=*reinterpret_cast<volatile const int *>(&i);
-        fence_after(order);
-        return v;
-    }
-    void store(T v, memory_order order=memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        fence_before(order);
-        *reinterpret_cast<volatile int *>(&i)=(int)v;
-    }
-    bool compare_exchange_weak(
-        T &expected,
-        T desired,
-        memory_order success_order,
-        memory_order failure_order) volatile BOOST_NOEXCEPT
-    {
-        fence_before(success_order);
-        int current, success;
-        __asm__ __volatile__(
-            "1: ldl_l %2, %4\n"
-            "cmpeq %2, %0, %3\n"
-            "mov %2, %0\n"
-            "beq %3, 3f\n"
-            "stl_c %1, %4\n"
-            "2:\n"
-
-            ".subsection 2\n"
-            "3: mov %3, %1\n"
-            "br 2b\n"
-            ".previous\n"
-
-            : "+&r" (expected), "+&r" (desired), "=&r"(current), "=&r"(success)
-            : "m" (i)
-            :
-        );
-        if (desired) fence_after(success_order);
-        else fence_after(failure_order);
-        return desired;
-    }
-
-    bool is_lock_free(void) const volatile BOOST_NOEXCEPT {return true;}
-protected:
-    inline T fetch_add_var(T c, memory_order order) volatile BOOST_NOEXCEPT
-    {
-        fence_before(order);
-        T original, modified;
-        __asm__ __volatile__(
-            "1: ldl_l %0, %2\n"
-            "addl %0, %3, %1\n"
-            "stl_c %1, %2\n"
-            "beq %1, 2f\n"
-
-            ".subsection 2\n"
-            "2: br 1b\n"
-            ".previous\n"
-
-            : "=&r" (original), "=&r" (modified)
-            : "m" (i), "r" (c)
-            :
-        );
-        fence_after(order);
-        return original;
-    }
-    inline T fetch_inc(memory_order order) volatile BOOST_NOEXCEPT
-    {
-        fence_before(order);
-        int original, modified;
-        __asm__ __volatile__(
-            "1: ldl_l %0, %2\n"
-            "addl %0, 1, %1\n"
-            "stl_c %1, %2\n"
-            "beq %1, 2f\n"
-
-            ".subsection 2\n"
-            "2: br 1b\n"
-            ".previous\n"
-
-            : "=&r" (original), "=&r" (modified)
-            : "m" (i)
-            :
-        );
-        fence_after(order);
-        return original;
-    }
-    inline T fetch_dec(memory_order order) volatile BOOST_NOEXCEPT
-    {
-        fence_before(order);
-        int original, modified;
-        __asm__ __volatile__(
-            "1: ldl_l %0, %2\n"
-            "subl %0, 1, %1\n"
-            "stl_c %1, %2\n"
-            "beq %1, 2f\n"
-
-            ".subsection 2\n"
-            "2: br 1b\n"
-            ".previous\n"
-
-            : "=&r" (original), "=&r" (modified)
-            : "m" (i)
-            :
-        );
-        fence_after(order);
-        return original;
-    }
-private:
-    T i;
-};
-
-template<typename T>
-class atomic_alpha_64
-{
-public:
-    typedef T integral_type;
-    BOOST_CONSTEXPR atomic_alpha_64(T v) BOOST_NOEXCEPT: i(v) {}
-    atomic_alpha_64() {}
-    T load(memory_order order=memory_order_seq_cst) const volatile
-    {
-        T v=*reinterpret_cast<volatile const T *>(&i);
-        fence_after(order);
-        return v;
-    }
-    void store(T v, memory_order order=memory_order_seq_cst) volatile BOOST_NOEXCEPT
-    {
-        fence_before(order);
-        *reinterpret_cast<volatile T *>(&i)=v;
-    }
-    bool compare_exchange_weak(
-        T &expected,
-        T desired,
-        memory_order success_order,
-        memory_order failure_order) volatile BOOST_NOEXCEPT
-    {
-        fence_before(success_order);
-        int current, success;
-        __asm__ __volatile__(
-            "1: ldq_l %2, %4\n"
-            "cmpeq %2, %0, %3\n"
-            "mov %2, %0\n"
-            "beq %3, 3f\n"
-            "stq_c %1, %4\n"
-            "2:\n"
-
-            ".subsection 2\n"
-            "3: mov %3, %1\n"
-            "br 2b\n"
-            ".previous\n"
-
-            : "+&r" (expected), "+&r" (desired), "=&r"(current), "=&r"(success)
-            : "m" (i)
-            :
-        );
-        if (desired) fence_after(success_order);
-        else fence_after(failure_order);
-        return desired;
-    }
-
-    bool is_lock_free(void) const volatile BOOST_NOEXCEPT {return true;}
-protected:
-    inline T fetch_add_var(T c, memory_order order) volatile BOOST_NOEXCEPT
-    {
-        fence_before(order);
-        T original, modified;
-        __asm__ __volatile__(
-            "1: ldq_l %0, %2\n"
-            "addq %0, %3, %1\n"
-            "stq_c %1, %2\n"
-            "beq %1, 2f\n"
-
-            ".subsection 2\n"
-            "2: br 1b\n"
-            ".previous\n"
-
-            : "=&r" (original), "=&r" (modified)
-            : "m" (i), "r" (c)
-            :
-        );
-        fence_after(order);
-        return original;
-    }
-    inline T fetch_inc(memory_order order) volatile BOOST_NOEXCEPT
-    {
-        fence_before(order);
-        T original, modified;
-        __asm__ __volatile__(
-            "1: ldq_l %0, %2\n"
-            "addq %0, 1, %1\n"
-            "stq_c %1, %2\n"
-            "beq %1, 2f\n"
-
-            ".subsection 2\n"
-            "2: br 1b\n"
-            ".previous\n"
-
-            : "=&r" (original), "=&r" (modified)
-            : "m" (i)
-            :
-        );
-        fence_after(order);
-        return original;
-    }
-    inline T fetch_dec(memory_order order) volatile BOOST_NOEXCEPT
-    {
-        fence_before(order);
-        T original, modified;
-        __asm__ __volatile__(
-            "1: ldq_l %0, %2\n"
-            "subq %0, 1, %1\n"
-            "stq_c %1, %2\n"
-            "beq %1, 2f\n"
-
-            ".subsection 2\n"
-            "2: br 1b\n"
-            ".previous\n"
-
-            : "=&r" (original), "=&r" (modified)
-            : "m" (i)
-            :
-        );
-        fence_after(order);
-        return original;
-    }
-private:
-    T i;
-};
-
-template<typename T>
-class platform_atomic_integral<T, 4> :
-    public build_atomic_from_typical<build_exchange<atomic_alpha_32<T> > >
-{
-public:
-    typedef build_atomic_from_typical<build_exchange<atomic_alpha_32<T> > > super;
-    BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
-    platform_atomic_integral(void) {}
-};
-
-template<typename T>
-class platform_atomic_integral<T, 8> :
-    public build_atomic_from_typical<build_exchange<atomic_alpha_64<T> > >
-{
-public:
-    typedef build_atomic_from_typical<build_exchange<atomic_alpha_64<T> > > super;
-    BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
-    platform_atomic_integral(void) {}
-};
-
-template<typename T>
-class platform_atomic_integral<T, 1> :
-    public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T>
-{
-public:
-    typedef build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> super;
-    BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
-    platform_atomic_integral(void) {}
-};
-
-template<typename T>
-class platform_atomic_integral<T, 2> :
-    public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T>
-{
-public:
-    typedef build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> super;
-    BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
-    platform_atomic_integral(void) {}
-};
-
-}
-}
-}
-
-#endif