Subversion Repositories openrisc

// -*- C++ -*- compatibility header.
 
// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
 
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
 
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.
 
/** @file bits/atomic_base.h
 *  This is a Standard C++ Library header.
 */
 
#include <bits/c++config.h>
#include <stddef.h>
#include <stdbool.h> // XXX need to define bool w/o stdbool.h in tr1/cstdbool
 
#ifndef _GLIBCXX_ATOMIC_BASE_H
#define _GLIBCXX_ATOMIC_BASE_H 1
 
_GLIBCXX_BEGIN_NAMESPACE(std)
_GLIBCXX_BEGIN_EXTERN_C
 
  /**
   * @defgroup atomics Atomics
   *
   * Components for performing atomic operations.
   * @{
   */
 
  /// Enumeration for memory_order
  typedef enum memory_order
    {
      memory_order_relaxed,
      memory_order_consume,
      memory_order_acquire,
      memory_order_release,
      memory_order_acq_rel,
      memory_order_seq_cst
    } memory_order;
 
  // Base for atomic_flag.
  typedef struct __atomic_flag_base
  {
    bool _M_i;
  } __atomic_flag_base;
 
#define ATOMIC_FLAG_INIT { false }
 
  /// 29.2 Lock-free Property
#if defined(_GLIBCXX_ATOMIC_BUILTINS_1) && defined(_GLIBCXX_ATOMIC_BUILTINS_2) \
  && defined(_GLIBCXX_ATOMIC_BUILTINS_4) && defined(_GLIBCXX_ATOMIC_BUILTINS_8)
# define _GLIBCXX_ATOMIC_PROPERTY 2
# define _GLIBCXX_ATOMIC_NAMESPACE __atomic2
#elif defined(_GLIBCXX_ATOMIC_BUILTINS_1)
# define _GLIBCXX_ATOMIC_PROPERTY 1
# define _GLIBCXX_ATOMIC_NAMESPACE __atomic1
#else
# define _GLIBCXX_ATOMIC_PROPERTY 0
# define _GLIBCXX_ATOMIC_NAMESPACE __atomic0
#endif
 
#define ATOMIC_INTEGRAL_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY
#define ATOMIC_ADDRESS_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY
 
  // Switch atomic integral base types based on C or C++.  In
  // addition, for "C" only provide type-generic macros for atomic
  // operations. (As C++ accomplishes the same thing with sets of
  // overloaded functions.
#ifdef __cplusplus
  inline namespace _GLIBCXX_ATOMIC_NAMESPACE { }
# include <bits/atomicfwd_cxx.h>
#else
# include <bits/atomicfwd_c.h>
#endif
 
  // Typedefs for other atomic integral types.
  typedef atomic_schar 		atomic_int_least8_t;
  typedef atomic_uchar 		atomic_uint_least8_t;
  typedef atomic_short 		atomic_int_least16_t;
  typedef atomic_ushort 	atomic_uint_least16_t;
  typedef atomic_int 		atomic_int_least32_t;
  typedef atomic_uint 		atomic_uint_least32_t;
  typedef atomic_llong 		atomic_int_least64_t;
  typedef atomic_ullong 	atomic_uint_least64_t;
 
  typedef atomic_schar 		atomic_int_fast8_t;
  typedef atomic_uchar 		atomic_uint_fast8_t;
  typedef atomic_short 		atomic_int_fast16_t;
  typedef atomic_ushort 	atomic_uint_fast16_t;
  typedef atomic_int 		atomic_int_fast32_t;
  typedef atomic_uint 		atomic_uint_fast32_t;
  typedef atomic_llong 		atomic_int_fast64_t;
  typedef atomic_ullong 	atomic_uint_fast64_t;
 
  typedef atomic_long 		atomic_intptr_t;
  typedef atomic_ulong 		atomic_uintptr_t;
 
  typedef atomic_long 		atomic_ssize_t;
  typedef atomic_ulong 		atomic_size_t;
 
  typedef atomic_llong 		atomic_intmax_t;
  typedef atomic_ullong 	atomic_uintmax_t;
 
  typedef atomic_long 		atomic_ptrdiff_t;
 
  // Accessor functions for base atomic_flag type.
  bool
  atomic_flag_test_and_set_explicit(__atomic_flag_base*, memory_order)
  _GLIBCXX_NOTHROW;
 
  inline bool
  atomic_flag_test_and_set(__atomic_flag_base* __a)
  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
 
  void
  atomic_flag_clear_explicit(__atomic_flag_base*, memory_order)
  _GLIBCXX_NOTHROW;
 
  inline void
  atomic_flag_clear(__atomic_flag_base* __a)
  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
 
  void
  __atomic_flag_wait_explicit(__atomic_flag_base*, memory_order)
  _GLIBCXX_NOTHROW;
 
  _GLIBCXX_CONST __atomic_flag_base*
  __atomic_flag_for_address(const void* __z) _GLIBCXX_NOTHROW;
 
  // Implementation specific defines.
#define _ATOMIC_LOAD_(__a, __x)						\
  ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_;			\
    atomic_flag* __g = __atomic_flag_for_address(__p); 			\
    __atomic_flag_wait_explicit(__g, __x);				\
    __typeof__ _ATOMIC_MEMBER_ __r = *__p;				\
    atomic_flag_clear_explicit(__g, __x);		       		\
    __r; })
 
#define _ATOMIC_STORE_(__a, __m, __x)					\
  ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_;			\
    __typeof__(__m) __v = (__m);			       		\
    atomic_flag* __g = __atomic_flag_for_address(__p); 			\
    __atomic_flag_wait_explicit(__g, __x);				\
    *__p = __v;								\
    atomic_flag_clear_explicit(__g, __x);		       		\
    __v; })
 
#define _ATOMIC_MODIFY_(__a, __o, __m, __x)				\
  ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_;			\
    __typeof__(__m) __v = (__m);			       		\
    atomic_flag* __g = __atomic_flag_for_address(__p); 			\
    __atomic_flag_wait_explicit(__g, __x);				\
    __typeof__ _ATOMIC_MEMBER_ __r = *__p;				\
    *__p __o __v;					       		\
    atomic_flag_clear_explicit(__g, __x);		       		\
    __r; })
 
#define _ATOMIC_CMPEXCHNG_(__a, __e, __m, __x)				\
  ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_;			\
    __typeof__(__e) __q = (__e);			       		\
    __typeof__(__m) __v = (__m);			       		\
    bool __r;						       		\
    atomic_flag* __g = __atomic_flag_for_address(__p); 			\
    __atomic_flag_wait_explicit(__g, __x);				\
    __typeof__ _ATOMIC_MEMBER_ __t__ = *__p;		       		\
    if (__t__ == *__q) { *__p = __v; __r = true; }			\
    else { *__q = __t__; __r = false; }		       			\
    atomic_flag_clear_explicit(__g, __x);		       		\
    __r; })
 
  // @} group atomics
 
_GLIBCXX_END_EXTERN_C
_GLIBCXX_END_NAMESPACE
 
// Inject into global namespace.
#ifdef __cplusplus
 
#include <atomic>
 
using std::memory_order;
using std::memory_order_relaxed;
using std::memory_order_consume;
using std::memory_order_acquire;
using std::memory_order_release;
using std::memory_order_acq_rel;
using std::memory_order_seq_cst;
using std::atomic_flag;
using std::atomic_bool;
using std::atomic_char;
using std::atomic_schar;
using std::atomic_uchar;
using std::atomic_short;
using std::atomic_ushort;
using std::atomic_int;
using std::atomic_uint;
using std::atomic_long;
using std::atomic_ulong;
using std::atomic_llong;
using std::atomic_ullong;
using std::atomic_wchar_t;
using std::atomic_char16_t;
using std::atomic_char32_t;
using std::atomic_address;
using std::atomic;
#endif
 
#endif