bsls_atomicoperations_x86_all_gcc.h

Go to the documentation of this file.

/// @file bsls_atomicoperations_x86_all_gcc.h
///
/// The content of this file has been pre-processed for Doxygen.
///
 
 
// bsls_atomicoperations_x86_all_gcc.h                                -*-C++-*-
#ifndef INCLUDED_BSLS_ATOMICOPERATIONS_X86_ALL_GCC
#define INCLUDED_BSLS_ATOMICOPERATIONS_X86_ALL_GCC
 
#include <bsls_ident.h>
BSLS_IDENT("$Id: $")
 
/// @defgroup bsls_atomicoperations_x86_all_gcc bsls_atomicoperations_x86_all_gcc
/// @brief  Provide implementations of atomic operations for X86/GCC.
/// @addtogroup bsl
/// @{
/// @addtogroup bsls
/// @{
/// @addtogroup bsls_atomicoperations_x86_all_gcc
/// @{
///
/// <h1> Outline </h1>
/// * <a href="#bsls_atomicoperations_x86_all_gcc-purpose"> Purpose</a>
/// * <a href="#bsls_atomicoperations_x86_all_gcc-classes"> Classes </a>
/// * <a href="#bsls_atomicoperations_x86_all_gcc-description"> Description </a>
///
/// # Purpose {#bsls_atomicoperations_x86_all_gcc-purpose}
/// Provide implementations of atomic operations for X86/GCC.
///
/// # Classes {#bsls_atomicoperations_x86_all_gcc-classes}
///
/// -  bsls::AtomicOperations_X86_ALL_GCC: implementation of atomics for X86/GCC.
///
/// # Description {#bsls_atomicoperations_x86_all_gcc-description}
/// This component provides classes necessary to implement atomics
/// on the Linux X86 platform with GCC.  The classes are for private use only.
/// See @ref bsls_atomicoperations  and @ref bsls_atomic  for the public interface to
/// atomics.
/// @}
/** @} */
/** @} */
 
/** @addtogroup bsl
 * @{
 */
/** @addtogroup bsls
 * @{
 */
/** @addtogroup bsls_atomicoperations_x86_all_gcc
 * @{
 */
 
#include <bsls_atomicoperations_default.h>
#include <bsls_platform.h>
#include <bsls_types.h>
 
#if defined(BSLS_PLATFORM_CPU_X86) \
    && (defined(BSLS_PLATFORM_CMP_GNU) || defined(BSLS_PLATFORM_CMP_CLANG))
 
 
 
namespace bsls {
 
struct AtomicOperations_X86_ALL_GCC;
typedef AtomicOperations_X86_ALL_GCC  AtomicOperations_Imp;
 
           // ======================================================
           // struct Atomic_TypeTraits<AtomicOperations_X86_ALL_GCC>
           // ======================================================
 
template <>
struct Atomic_TypeTraits<AtomicOperations_X86_ALL_GCC>
{
    struct Int
    {
        volatile int d_value __attribute__((__aligned__(sizeof(int))));
    };
 
    struct Int64
    {
        volatile Types::Int64 d_value
                       __attribute__((__aligned__(sizeof(Types::Int64))));
    };
 
    struct Uint
    {
        volatile unsigned int d_value
                            __attribute__((__aligned__(sizeof(unsigned int))));
    };
 
    struct Uint64
    {
        volatile Types::Uint64 d_value
                       __attribute__((__aligned__(sizeof(Types::Uint64))));
    };
 
    struct Pointer
    {
        void * volatile d_value __attribute__((__aligned__(sizeof(void *))));
    };
};
 
                     // ===================================
                     // struct AtomicOperations_X86_ALL_GCC
                     // ===================================
 
struct AtomicOperations_X86_ALL_GCC
    : AtomicOperations_Default32<AtomicOperations_X86_ALL_GCC>
{
    typedef Atomic_TypeTraits<AtomicOperations_X86_ALL_GCC> AtomicTypes;
 
        // *** atomic functions for int ***
 
    static int getInt(const AtomicTypes::Int *atomicInt);
 
    static void setInt(AtomicTypes::Int *atomicInt, int value);
 
    static void setIntRelease(AtomicTypes::Int *atomicInt, int value);
 
    static int swapInt(AtomicTypes::Int *atomicInt, int swapValue);
 
    static int testAndSwapInt(AtomicTypes::Int *atomicInt,
                              int compareValue,
                              int swapValue);
 
    static int addIntNv(AtomicTypes::Int *atomicInt, int value);
 
        // *** atomic functions for Int64 ***
 
    static Types::Int64 getInt64(const AtomicTypes::Int64 *atomicInt);
 
    static void setInt64(AtomicTypes::Int64 *atomicInt, Types::Int64 value);
 
    static Types::Int64 swapInt64(AtomicTypes::Int64  *atomicInt,
                                  Types::Int64 swapValue);
 
    static Types::Int64 testAndSwapInt64(AtomicTypes::Int64 *atomicInt,
                                         Types::Int64 compareValue,
                                         Types::Int64 swapValue);
 
    static Types::Int64 addInt64Nv(AtomicTypes::Int64 *atomicInt,
                                   Types::Int64 value);
};
 
// ===========================================================================
//                        INLINE FUNCTION DEFINITIONS
// ===========================================================================
 
                     // -----------------------------------
                     // struct AtomicOperations_X86_ALL_GCC
                     // -----------------------------------
 
inline
int AtomicOperations_X86_ALL_GCC::
    getInt(const AtomicTypes::Int *atomicInt)
{
    int result;
 
    asm volatile (
        "       movl %[obj], %[res]     \n\t"
 
                : [res] "=r" (result)
                : [obj] "m"  (*atomicInt)
                : "memory");
 
    return result;
}
 
inline
void AtomicOperations_X86_ALL_GCC::
    setInt(AtomicTypes::Int *atomicInt, int value)
{
#ifdef __SSE2__
    asm volatile (
        "       movl %[val], %[obj]     \n\t"
        "       mfence                  \n\t"
 
                : [obj] "=m" (*atomicInt)
                : [val] "r"  (value)
                : "memory");
#else
    asm volatile (
        "       movl %[val], %[obj]     \n\t"
        "       lock addl $0, 0(%%esp)  \n\t"
 
                : [obj] "=m" (*atomicInt)
                : [val] "r"  (value)
                : "memory", "cc");
#endif
}
 
inline
void AtomicOperations_X86_ALL_GCC::
    setIntRelease(AtomicTypes::Int *atomicInt, int value)
{
    asm volatile (
        "       movl %[val], %[obj]     \n\t"
 
                : [obj] "=m" (*atomicInt)
                : [val] "r"  (value)
                : "memory");
}
 
inline
int AtomicOperations_X86_ALL_GCC::
    swapInt(AtomicTypes::Int *atomicInt, int swapValue)
{
    asm volatile (
        "       lock xchgl %[val], %[obj]   \n\t"
 
                : [obj] "=m" (*atomicInt),
                  [val] "=r" (swapValue)
                : "1" (swapValue), "m" (*atomicInt)
                : "memory");
 
    return swapValue;
}
 
inline
int AtomicOperations_X86_ALL_GCC::
    testAndSwapInt(AtomicTypes::Int *atomicInt,
                   int compareValue,
                   int swapValue)
{
    return __sync_val_compare_and_swap(&atomicInt->d_value,
                                       compareValue,
                                       swapValue);
}
 
inline
int AtomicOperations_X86_ALL_GCC::
    addIntNv(AtomicTypes::Int *atomicInt, int value)
{
    return __sync_add_and_fetch(&atomicInt->d_value, value);
}
 
inline
Types::Int64 AtomicOperations_X86_ALL_GCC::
    getInt64(const AtomicTypes::Int64 *atomicInt)
{
#if BSLS_PLATFORM_CMP_VER_MAJOR >= 40300 // gcc >= 4.3
    Types::Int64 value = atomicInt->d_value;
    return __sync_val_compare_and_swap(
                const_cast<Types::Int64 *>(&atomicInt->d_value),
                value,
                value);
#else
    Types::Int64 result;
    asm volatile (
#ifdef __PIC__
        "       pushl %%ebx                 \n\t"
#endif
        "       movl %%ebx, %%eax           \n\t"
        "       movl %%ecx, %%edx           \n\t"
#if __GNUC__ != 3
        "       lock cmpxchg8b %[obj]       \n\t"
#else
        // gcc 3.4 seems to think that it can take edx as %1.
        "       lock cmpxchg8b (%[obj])     \n\t"
#endif
#ifdef __PIC__
        "       popl %%ebx                  \n\t"
#endif
                : [res] "=&A" (result)
                :
#if __GNUC__ != 3
                  [obj] "m" (*atomicInt),
#else
                  [obj] "S" (atomicInt),
#endif
                  "0" (0)
                :
#ifndef __PIC__
                  "ebx",
#endif
 
#if defined(BSLS_PLATFORM_CMP_CLANG) && defined(__PIC__)
                  "ebx",    // Clang wants to reuse 'ebx' even in PIC mode
                            // and generates invalid code.
                            // Mark 'ebx' as clobbered to prevent that.
#endif
                  "ecx", "cc", "memory");
    return result;
#endif
 
}
 
inline
void AtomicOperations_X86_ALL_GCC::
    setInt64(AtomicTypes::Int64 *atomicInt, Types::Int64 value)
{
    swapInt64(atomicInt, value);
}
 
inline
Types::Int64 AtomicOperations_X86_ALL_GCC::
    swapInt64(AtomicTypes::Int64 *atomicInt,
              Types::Int64 swapValue)
{
#if BSLS_PLATFORM_CMP_VER_MAJOR >= 40300 // gcc >= 4.3
    Types::Int64 oldValue;
 
    do
    {
        oldValue = atomicInt->d_value;
    } while (__sync_val_compare_and_swap(&atomicInt->d_value,
                                         oldValue,
                                         swapValue)
             != oldValue);
 
    return oldValue;
#else
    Types::Int64 result;
    asm volatile (
#ifdef __PIC__
        "       pushl %%ebx             \n\t"
        "       movl  %[val], %%ebx     \n\t"
#endif
        "1:                             \n\t"
        "       lock cmpxchg8b %[obj]   \n\t"
        "       jnz 1b                  \n\t"
#ifdef __PIC__
        "       popl %%ebx              \n\t"
#endif
                : [res] "=A" (result),
                  [obj] "+m" (*atomicInt)
                :
#ifdef __PIC__
                  [val] "g" ((unsigned int) swapValue),
#else
                  [val] "b" ((unsigned int) swapValue),
#endif
                  "c" ((int) (swapValue >> 32)),
                  "A" (*atomicInt)
                :
#if defined(BSLS_PLATFORM_CMP_CLANG) && defined(__PIC__)
                  "ebx",    // Clang wants to reuse 'ebx' even in PIC mode
                            // and generates invalid code.
                            // Mark 'ebx' as clobbered to prevent that.
#endif
                  "memory", "cc");
 
    return result;
#endif
}
 
inline
Types::Int64 AtomicOperations_X86_ALL_GCC::
    testAndSwapInt64(AtomicTypes::Int64 *atomicInt,
                     Types::Int64 compareValue,
                     Types::Int64 swapValue)
{
#if BSLS_PLATFORM_CMP_VER_MAJOR >= 40300 // gcc >= 4.3
    return __sync_val_compare_and_swap(&atomicInt->d_value,
                                       compareValue,
                                       swapValue);
#else
    asm volatile (
#ifdef __PIC__
        "       pushl   %%ebx               \n\t"
        "       movl    %[val], %%ebx       \n\t"
#endif
        "       lock cmpxchg8b %[obj]       \n\t"
#ifdef __PIC__
        "       popl    %%ebx               \n\t"
#endif
                : [cmp] "=A" (compareValue),
                  [obj] "+m" (*atomicInt)
                :
#ifdef __PIC__
                  [val] "g" ((unsigned int) swapValue),
#else
                  [val] "b" ((unsigned int) swapValue),
#endif
                  "c" ((int) (swapValue >> 32)),
                  "0" (compareValue)
                :
#if defined(BSLS_PLATFORM_CMP_CLANG) && defined(__PIC__)
                  "ebx",    // Clang wants to reuse 'ebx' even in PIC mode
                            // and generates invalid code.
                            // Mark 'ebx' as clobbered to prevent that.
#endif
                  "memory", "cc");
 
    return compareValue;
#endif
}
 
inline
Types::Int64 AtomicOperations_X86_ALL_GCC::
    addInt64Nv(AtomicTypes::Int64 *atomicInt,
               Types::Int64 value)
{
    return __sync_add_and_fetch(&atomicInt->d_value, value);
}
 
}  // close package namespace
 
 
 
#endif  // defined(BSLS_PLATFORM_CPU_X86) && (CMP_GNU || CMP_CLANG)
 
#endif
 
// ----------------------------------------------------------------------------
// Copyright 2013 Bloomberg Finance L.P.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ----------------------------- END-OF-FILE ----------------------------------
 
/** @} */
/** @} */
/** @} */