API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 15th, 2019
109
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 51.32 KB | None | 0 0
raw download clone embed print report
  1. // xxatomic internal header
  2. // NOTE: no include guard
  3.  
  4. // Defines struct _ATOMIC_ITYPE, an atomic struct that manages objects
  5. // of type _ITYPE whose size is _ISIZE bytes. Also defines the non-member
  6. // and member functions for atomic operations on _ATOMIC_TYPE.
  7. //
  8. // Used by header <atomic> to define atomic types for integral types and
  9. // addresses.
  10.  
  11. // Every occurrence of __declspec(nothrow) in this file is TRANSITION, VSO#174686
  12.  
  13. static_assert(_ISIZE == sizeof (_ITYPE),
  14.     "_ISIZE and _ITYPE should match.");
  15.  
  16. #define _ATOMIC_UINT _CONCAT(_CONCAT(_Uint, _ISIZE), _t)
  17. #define _ATOMIC_LOCK_FREE_PRIMITIVE_NAME(name)  \
  18.     _CONCAT(name, _ISIZE)
  19. #define _ATOMIC_LOCKING_PRIMITIVE_NAME(name)    \
  20.     _CONCAT(_CONCAT(name, _ISIZE), _locking)
  21.  
  22.   #define _ATOMIC_STORE(_Atom, _Value, _Order)  \
  23.     _ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_store_)\
  24.         ((_ATOMIC_UINT*)&_Atom->_My_val,    \
  25.         (_ATOMIC_UINT)_Value, _Order)
  26.  
  27.   #define _ATOMIC_LOAD(_Atom, _Order)   \
  28.     (_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_load_) \
  29.     ((_ATOMIC_UINT*)&_Atom->_My_val, _Order)
  30.  
  31.   #define _ATOMIC_EXCHANGE(_Atom, _Value, _Order)   \
  32.     (_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_exchange_) \
  33.     ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)
  34.  
  35.   #define _ATOMIC_COMPARE_EXCHANGE_WEAK(_Atom, _Expected, _Desired,\
  36.     _Order1, _Order2)   \
  37.     _ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_compare_exchange_weak_)    \
  38.     ((_ATOMIC_UINT*)&_Atom->_My_val,    \
  39.         (_ATOMIC_UINT*)_Expected, (_ATOMIC_UINT)_Value, \
  40.         _Order1, _Order2)
  41.  
  42.   #define _ATOMIC_COMPARE_EXCHANGE_STRONG(_Atom, _Expected, _Desired,\
  43.     _Order1, _Order2)   \
  44.     _ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_compare_exchange_strong_)  \
  45.     ((_ATOMIC_UINT*)&_Atom->_My_val,    \
  46.         (_ATOMIC_UINT*)_Expected, (_ATOMIC_UINT)_Value, \
  47.         _Order1, _Order2)
  48.  
  49.   #define _ATOMIC_FETCH_ADD(_Atom, _Value, _Order)  \
  50.     (_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_add_)    \
  51.     ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)
  52.  
  53.   #define _ATOMIC_FETCH_SUB(_Atom, _Value, _Order)  \
  54.     (_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_sub_)    \
  55.     ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)
  56.  
  57.   #define _ATOMIC_FETCH_AND(_Atom, _Value, _Order)  \
  58.     (_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_and_)    \
  59.     ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)
  60.  
  61.   #define _ATOMIC_FETCH_OR(_Atom, _Value, _Order)   \
  62.     (_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_or_) \
  63.     ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)
  64.  
  65.   #define _ATOMIC_FETCH_XOR(_Atom, _Value, _Order)  \
  66.     (_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_xor_)    \
  67.     ((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)
  68.  
  69.         // STRUCT _ATOMIC_ITYPE
  70. typedef struct _ATOMIC_ITYPE
  71.     {   // struct for atomic operations on type _ITYPE
  72.     __declspec(nothrow) _ITYPE operator=(_ITYPE) volatile;
  73.     __declspec(nothrow) _ITYPE operator=(_ITYPE);
  74.  
  75. #if _HAS_CXX17
  76.     static constexpr bool is_always_lock_free = true;
  77.     static constexpr bool _Is_usually_lock_free = true;
  78. #endif /* _HAS_CXX17 */
  79.  
  80.     _NODISCARD __declspec(nothrow) bool is_lock_free() const volatile;
  81.     _NODISCARD __declspec(nothrow) bool is_lock_free() const;
  82.     __declspec(nothrow) void store(_ITYPE, memory_order = memory_order_seq_cst) volatile;
  83.     __declspec(nothrow) void store(_ITYPE, memory_order = memory_order_seq_cst);
  84.     _NODISCARD __declspec(nothrow) _ITYPE load(memory_order = memory_order_seq_cst) const volatile;
  85.     _NODISCARD __declspec(nothrow) _ITYPE load(memory_order = memory_order_seq_cst) const;
  86. #ifndef _ATOMIC_IS_ADDRESS_TYPE
  87.     __declspec(nothrow) operator _ITYPE() const volatile;
  88.     __declspec(nothrow) operator _ITYPE() const;
  89. #endif /* _ATOMIC_IS_ADDRESS_TYPE */
  90.     __declspec(nothrow) _ITYPE exchange(_ITYPE, memory_order = memory_order_seq_cst) volatile;
  91.     __declspec(nothrow) _ITYPE exchange(_ITYPE, memory_order = memory_order_seq_cst);
  92.     __declspec(nothrow) bool compare_exchange_weak(_ITYPE&, _ITYPE, memory_order, memory_order) volatile;
  93.     __declspec(nothrow) bool compare_exchange_weak(_ITYPE&, _ITYPE, memory_order, memory_order);
  94.     __declspec(nothrow) bool compare_exchange_strong(_ITYPE&, _ITYPE, memory_order, memory_order) volatile;
  95.     __declspec(nothrow) bool compare_exchange_strong(_ITYPE&, _ITYPE, memory_order, memory_order);
  96.     __declspec(nothrow) bool compare_exchange_weak(_ITYPE&, _ITYPE, memory_order = memory_order_seq_cst) volatile;
  97.     __declspec(nothrow) bool compare_exchange_weak(_ITYPE&, _ITYPE, memory_order = memory_order_seq_cst);
  98.     __declspec(nothrow) bool compare_exchange_strong(_ITYPE&, _ITYPE, memory_order = memory_order_seq_cst) volatile;
  99.     __declspec(nothrow) bool compare_exchange_strong(_ITYPE&, _ITYPE, memory_order = memory_order_seq_cst);
  100.  
  101.  #ifdef _ATOMIC_HAS_ARITHMETIC_OPS
  102.     __declspec(nothrow) _ITYPE operator++(int) volatile;
  103.     __declspec(nothrow) _ITYPE operator++(int);
  104.     __declspec(nothrow) _ITYPE operator--(int) volatile;
  105.     __declspec(nothrow) _ITYPE operator--(int);
  106.     __declspec(nothrow) _ITYPE operator++() volatile;
  107.     __declspec(nothrow) _ITYPE operator++();
  108.     __declspec(nothrow) _ITYPE operator--() volatile;
  109.     __declspec(nothrow) _ITYPE operator--();
  110.     __declspec(nothrow) _ITYPE operator+=(_ITYPE) volatile;
  111.     __declspec(nothrow) _ITYPE operator+=(_ITYPE);
  112.     __declspec(nothrow) _ITYPE operator-=(_ITYPE) volatile;
  113.     __declspec(nothrow) _ITYPE operator-=(_ITYPE);
  114.     __declspec(nothrow) _ITYPE operator&=(_ITYPE) volatile;
  115.     __declspec(nothrow) _ITYPE operator&=(_ITYPE);
  116.     __declspec(nothrow) _ITYPE operator|=(_ITYPE) volatile;
  117.     __declspec(nothrow) _ITYPE operator|=(_ITYPE);
  118.     __declspec(nothrow) _ITYPE operator^=(_ITYPE) volatile;
  119.     __declspec(nothrow) _ITYPE operator^=(_ITYPE);
  120.  
  121.     __declspec(nothrow) _ITYPE fetch_add(_ITYPE, memory_order = memory_order_seq_cst) volatile;
  122.     __declspec(nothrow) _ITYPE fetch_add(_ITYPE, memory_order = memory_order_seq_cst);
  123.     __declspec(nothrow) _ITYPE fetch_sub(_ITYPE, memory_order = memory_order_seq_cst) volatile;
  124.     __declspec(nothrow) _ITYPE fetch_sub(_ITYPE, memory_order = memory_order_seq_cst);
  125.     __declspec(nothrow) _ITYPE fetch_and(_ITYPE, memory_order = memory_order_seq_cst) volatile;
  126.     __declspec(nothrow) _ITYPE fetch_and(_ITYPE, memory_order = memory_order_seq_cst);
  127.     __declspec(nothrow) _ITYPE fetch_or(_ITYPE, memory_order = memory_order_seq_cst) volatile;
  128.     __declspec(nothrow) _ITYPE fetch_or(_ITYPE, memory_order = memory_order_seq_cst);
  129.     __declspec(nothrow) _ITYPE fetch_xor(_ITYPE, memory_order = memory_order_seq_cst) volatile;
  130.     __declspec(nothrow) _ITYPE fetch_xor(_ITYPE, memory_order = memory_order_seq_cst);
  131.  #endif /* _ATOMIC_HAS_ARITHMETIC_OPS */
  132.  
  133.  #ifdef _ATOMIC_IS_ADDRESS_TYPE
  134.     __declspec(nothrow) _ITYPE fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
  135.     __declspec(nothrow) _ITYPE fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);
  136.     __declspec(nothrow) _ITYPE fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
  137.     __declspec(nothrow) _ITYPE fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);
  138.     __declspec(nothrow) _ITYPE operator+=(ptrdiff_t) volatile;
  139.     __declspec(nothrow) _ITYPE operator+=(ptrdiff_t);
  140.     __declspec(nothrow) _ITYPE operator-=(ptrdiff_t) volatile;
  141.     __declspec(nothrow) _ITYPE operator-=(ptrdiff_t);
  142.  #endif /* _ATOMIC_IS_ADDRESS_TYPE */
  143.  
  144.  
  145. // x86's stack is 4-aligned, but atomic<int64_t> needs to be 8-aligned.
  146. // Don't change this setting unless you know exactly what you're doing.
  147.  
  148.  #ifndef _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS
  149.   #define _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS 1
  150.  #endif /* _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS */
  151.  
  152.  #if _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS
  153.     alignas(sizeof(_ATOMIC_UINT)) _ATOMIC_UINT _My_val;
  154.  #else /* _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS */
  155.     _ATOMIC_UINT _My_val;
  156.  #endif /* _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS */
  157.  
  158.     } _ATOMIC_ITYPE;
  159.  
  160.  #ifndef _ATOMIC_HAS_NO_SPECIALIZATION
  161.         // TEMPLATE SPECIALIZATION atomic<_ITYPE>
  162. template<>
  163.     struct atomic<_ITYPE>
  164.         : _ATOMIC_ITYPE
  165.     {   /* template specialization that manages
  166.             values of _ITYPE atomically */
  167.     using value_type = _ITYPE;
  168.     using difference_type = _ITYPE;
  169.  
  170.     atomic() _NOEXCEPT = default;
  171.  
  172.     __declspec(nothrow) constexpr atomic(_ITYPE _Val)
  173.         : _ATOMIC_ITYPE{(_ATOMIC_UINT)_Val}
  174.         {   // construct from _Val, initialization is not atomic
  175.         }
  176.  
  177.     __declspec(nothrow) _ITYPE operator=(_ITYPE _Val) volatile
  178.         {   // assign from _Val
  179.         return (_ATOMIC_ITYPE::operator=(_Val));
  180.         }
  181.  
  182.     __declspec(nothrow) _ITYPE operator=(_ITYPE _Val)
  183.         {   // assign from _Val
  184.         return (_ATOMIC_ITYPE::operator=(_Val));
  185.         }
  186.  
  187.     atomic(const atomic&) = delete;
  188.     atomic& operator=(const atomic&) = delete;
  189.     atomic& operator=(const atomic&) volatile = delete;
  190.     };
  191.  #endif /* _ATOMIC_HAS_NO_SPECIALIZATION */
  192.  
  193.  #ifdef _ATOMIC_IS_ADDRESS_TYPE
  194.         // STRUCT TEMPLATE PARTIAL SPECIALIZATION atomic<_Ty *>
  195. template<class _Ty>
  196.     struct atomic<_Ty *>
  197.         : _Atomic_address
  198.     {   // template that manages values of _Ty * atomically
  199.     using value_type = _Ty *;
  200.     using difference_type = ptrdiff_t;
  201.  
  202.     atomic(const atomic&) = delete;
  203.     atomic& operator=(const atomic&) = delete;
  204.     atomic& operator=(const atomic&) volatile = delete;
  205.  
  206.     atomic() _NOEXCEPT = default;
  207.  
  208.     __declspec(nothrow) constexpr atomic(_Ty *_Right)
  209.         : _Atomic_address{(_ATOMIC_UINT)_Right}
  210.         {   // construct from _Right, initialization is not atomic
  211.         }
  212.  
  213.     __declspec(nothrow) _Ty *operator=(_Ty *_Right) volatile
  214.         {   // assign from _Right
  215.         return (reinterpret_cast<_Ty *>(
  216.             _Atomic_address::operator=((void *)_Right)));
  217.         }
  218.  
  219.     __declspec(nothrow) _Ty *operator=(_Ty *_Right)
  220.         {   // assign from _Right
  221.         return (reinterpret_cast<_Ty *>(
  222.             _Atomic_address::operator=((void *)_Right)));
  223.         }
  224.  
  225.     __declspec(nothrow) void store(_Ty *_Value, memory_order _Order = memory_order_seq_cst) volatile
  226.         {   // store _Value into *this
  227.         _Atomic_address::store((void *)_Value, _Order);
  228.         }
  229.  
  230.     __declspec(nothrow) void store(_Ty *_Value, memory_order _Order = memory_order_seq_cst)
  231.         {   // store _Value into *this
  232.         _Atomic_address::store((void *)_Value, _Order);
  233.         }
  234.  
  235.     _NODISCARD __declspec(nothrow) _Ty *load(memory_order _Order = memory_order_seq_cst) const volatile
  236.         {   // return value held in *this
  237.         return (reinterpret_cast<_Ty *>(_Atomic_address::load(_Order)));
  238.         }
  239.  
  240.     _NODISCARD __declspec(nothrow) _Ty *load(memory_order _Order = memory_order_seq_cst) const
  241.         {   // return value held in *this
  242.         return (reinterpret_cast<_Ty *>(_Atomic_address::load(_Order)));
  243.         }
  244.  
  245.     __declspec(nothrow) operator _Ty *() const volatile
  246.         {   // return value held in *this
  247.         return (load());
  248.         }
  249.  
  250.     __declspec(nothrow) operator _Ty *() const
  251.         {   // return value held in *this
  252.         return (load());
  253.         }
  254.  
  255.     __declspec(nothrow) _Ty *exchange(_Ty *_Value, memory_order _Order = memory_order_seq_cst) volatile
  256.         {   // exchange value stored in *this with _Value
  257.         return (reinterpret_cast<_Ty *>(_Atomic_address::exchange(
  258.             (void *)_Value, _Order)));
  259.         }
  260.  
  261.     __declspec(nothrow) _Ty *exchange(_Ty *_Value, memory_order _Order = memory_order_seq_cst)
  262.         {   // exchange value stored in *this with _Value
  263.         return (reinterpret_cast<_Ty *>(_Atomic_address::exchange(
  264.             (void *)_Value, _Order)));
  265.         }
  266.  
  267.     __declspec(nothrow) bool compare_exchange_weak(
  268.         _Ty *& _Exp, _Ty *_Value,
  269.         memory_order _Order1, memory_order _Order2) volatile
  270.         {   // compare and exchange value stored in *this with *_Exp, _Value
  271.         return (_Atomic_address::compare_exchange_weak(
  272.             (void *&)_Exp, (void *)_Value, _Order1, _Order2));
  273.         }
  274.  
  275.     __declspec(nothrow) bool compare_exchange_weak(
  276.         _Ty *& _Exp, _Ty *_Value,
  277.         memory_order _Order1, memory_order _Order2)
  278.         {   // compare and exchange value stored in *this with *_Exp, _Value
  279.         return (_Atomic_address::compare_exchange_weak(
  280.             (void *&)_Exp, (void *)_Value, _Order1, _Order2));
  281.         }
  282.  
  283.     __declspec(nothrow) bool compare_exchange_weak(
  284.         _Ty *& _Exp, _Ty *_Value,
  285.         memory_order _Order = memory_order_seq_cst) volatile
  286.         {   // compare and exchange value stored in *this with *_Exp, _Value
  287.         return (_Atomic_address::compare_exchange_weak(
  288.             (void *&)_Exp, (void *)_Value, _Order));
  289.         }
  290.  
  291.     __declspec(nothrow) bool compare_exchange_weak(
  292.         _Ty *& _Exp, _Ty *_Value,
  293.         memory_order _Order = memory_order_seq_cst)
  294.         {   // compare and exchange value stored in *this with *_Exp, _Value
  295.         return (_Atomic_address::compare_exchange_weak(
  296.             (void *&)_Exp, (void *)_Value, _Order));
  297.         }
  298.  
  299.     __declspec(nothrow) bool compare_exchange_strong(
  300.         _Ty *& _Exp, _Ty *_Value,
  301.         memory_order _Order1, memory_order _Order2) volatile
  302.         {   // compare and exchange value stored in *this with *_Exp, _Value
  303.         return (_Atomic_address::compare_exchange_strong(
  304.             (void *&)_Exp, (void *)_Value, _Order1, _Order2));
  305.         }
  306.  
  307.     __declspec(nothrow) bool compare_exchange_strong(
  308.         _Ty *& _Exp, _Ty *_Value,
  309.         memory_order _Order1, memory_order _Order2)
  310.         {   // compare and exchange value stored in *this with *_Exp, _Value
  311.         return (_Atomic_address::compare_exchange_strong(
  312.             (void *&)_Exp, (void *)_Value, _Order1, _Order2));
  313.         }
  314.  
  315.     __declspec(nothrow) bool compare_exchange_strong(
  316.         _Ty *& _Exp, _Ty *_Value,
  317.         memory_order _Order = memory_order_seq_cst) volatile
  318.         {   // compare and exchange value stored in *this with *_Exp, _Value
  319.         return (_Atomic_address::compare_exchange_strong(
  320.             (void *&)_Exp, (void *)_Value, _Order));
  321.         }
  322.  
  323.     __declspec(nothrow) bool compare_exchange_strong(
  324.         _Ty *& _Exp, _Ty *_Value,
  325.         memory_order _Order = memory_order_seq_cst)
  326.         {   // compare and exchange value stored in *this with *_Exp, _Value
  327.         return (_Atomic_address::compare_exchange_strong(
  328.             (void *&)_Exp, (void *)_Value, _Order));
  329.         }
  330.  
  331.     __declspec(nothrow) _Ty *fetch_add(ptrdiff_t _Value, memory_order _Order = memory_order_seq_cst) volatile
  332.         {   // add _Value to value stored in *this
  333.         return (reinterpret_cast<_Ty *>(
  334.             _Atomic_address::fetch_add(_Value * sizeof (_Ty), _Order)));
  335.         }
  336.  
  337.     __declspec(nothrow) _Ty *fetch_add(ptrdiff_t _Value, memory_order _Order = memory_order_seq_cst)
  338.         {   // add _Value to value stored in *this
  339.         return (reinterpret_cast<_Ty *>(
  340.             _Atomic_address::fetch_add(_Value * sizeof (_Ty), _Order)));
  341.         }
  342.  
  343.     __declspec(nothrow) _Ty *fetch_sub(ptrdiff_t _Value, memory_order _Order = memory_order_seq_cst) volatile
  344.         {   // subtract _Value from value stored in *this
  345.         return (reinterpret_cast<_Ty *>(
  346.             _Atomic_address::fetch_sub(_Value * sizeof (_Ty), _Order)));
  347.         }
  348.  
  349.     __declspec(nothrow) _Ty *fetch_sub(ptrdiff_t _Value, memory_order _Order = memory_order_seq_cst)
  350.         {   // subtract _Value from value stored in *this
  351.         return (reinterpret_cast<_Ty *>(
  352.             _Atomic_address::fetch_sub(_Value * sizeof (_Ty), _Order)));
  353.         }
  354.  
  355.     __declspec(nothrow) _Ty *operator++(int) volatile
  356.         {   // increment stored pointer
  357.         return (fetch_add(1));
  358.         }
  359.  
  360.     __declspec(nothrow) _Ty *operator++(int)
  361.         {   // increment stored pointer
  362.         return (fetch_add(1));
  363.         }
  364.  
  365.     __declspec(nothrow) _Ty *operator--(int) volatile
  366.         {   // decrement stored pointer
  367.         return (fetch_sub(1));
  368.         }
  369.  
  370.     __declspec(nothrow) _Ty *operator--(int)
  371.         {   // decrement stored pointer
  372.         return (fetch_sub(1));
  373.         }
  374.  
  375.     __declspec(nothrow) _Ty *operator+=(ptrdiff_t _Right) volatile
  376.         {   // add _Right to value stored in *this
  377.         return (fetch_add(_Right) + _Right);
  378.         }
  379.  
  380.     __declspec(nothrow) _Ty *operator+=(ptrdiff_t _Right)
  381.         {   // add _Right to value stored in *this
  382.         return (fetch_add(_Right) + _Right);
  383.         }
  384.  
  385.     __declspec(nothrow) _Ty *operator-=(ptrdiff_t _Right) volatile
  386.         {   // subtract _Right from value stored in *this
  387.         return (fetch_sub(_Right) - _Right);
  388.         }
  389.  
  390.     __declspec(nothrow) _Ty *operator-=(ptrdiff_t _Right)
  391.         {   // subtract _Right from value stored in *this
  392.         return (fetch_sub(_Right) - _Right);
  393.         }
  394.  
  395.     __declspec(nothrow) _Ty *operator++() volatile
  396.         {   // increment stored pointer
  397.         return (*this += 1);
  398.         }
  399.  
  400.     __declspec(nothrow) _Ty *operator++()
  401.         {   // increment stored pointer
  402.         return (*this += 1);
  403.         }
  404.  
  405.     __declspec(nothrow) _Ty *operator--() volatile
  406.         {   // decrement stored pointer
  407.         return (*this -= 1);
  408.         }
  409.  
  410.     __declspec(nothrow) _Ty *operator--()
  411.         {   // decrement stored pointer
  412.         return (*this -= 1);
  413.         }
  414.     };
  415.  #endif /* _ATOMIC_IS_ADDRESS_TYPE */
  416.  
  417.         // CORE NON-MEMBER FUNCTIONS
  418.     // FUNCTION TEMPLATE atomic_is_lock_free
  419. _NODISCARD __declspec(nothrow) inline bool atomic_is_lock_free(const volatile _ATOMIC_ITYPE *)
  420.     {   // return true if operations on _ATOMIC_ITYPE are lock-free
  421.     return (true);
  422.     }
  423.  
  424. _NODISCARD __declspec(nothrow) inline bool atomic_is_lock_free(const _ATOMIC_ITYPE *)
  425.     {   // return true if operations on _ATOMIC_ITYPE are lock-free
  426.     return (true);
  427.     }
  428.  
  429.  #ifndef _ATOMIC_HAS_NO_SPECIALIZATION
  430. _NODISCARD __declspec(nothrow) inline bool atomic_is_lock_free(const volatile atomic<_ITYPE> *)
  431.     {   // return true if operations on _ATOMIC_ITYPE are lock-free
  432.     return (true);
  433.     }
  434.  
  435. _NODISCARD __declspec(nothrow) inline bool atomic_is_lock_free(const atomic<_ITYPE> *)
  436.     {   // return true if operations on _ATOMIC_ITYPE are lock-free
  437.     return (true);
  438.     }
  439.  #endif /* _ATOMIC_HAS_NO_SPECIALIZATION */
  440.  
  441.     // FUNCTION TEMPLATE atomic_init
  442. __declspec(nothrow) inline void atomic_init(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  443.     {   // non-atomically initialize *_Atom to _Value
  444.     _Atom->_My_val = (_ATOMIC_UINT)_Value;
  445.  
  446.     }
  447.  
  448. __declspec(nothrow) inline void atomic_init(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  449.     {   // non-atomically initialize *_Atom to _Value
  450.     _Atom->_My_val = (_ATOMIC_UINT)_Value;
  451.  
  452.     }
  453.  
  454.  #ifndef _ATOMIC_HAS_NO_SPECIALIZATION
  455. __declspec(nothrow) inline void atomic_init(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
  456.     {   // non-atomically initialize *_Atom to _Value
  457.     _Atom->_My_val = (_ATOMIC_UINT)_Value;
  458.  
  459.     }
  460.  
  461. __declspec(nothrow) inline void atomic_init(atomic<_ITYPE> *_Atom, _ITYPE _Value)
  462.     {   // non-atomically initialize *_Atom to _Value
  463.     _Atom->_My_val = (_ATOMIC_UINT)_Value;
  464.  
  465.     }
  466.  #endif /* _ATOMIC_HAS_NO_SPECIALIZATION */
  467.  
  468. __declspec(nothrow) inline void atomic_store_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
  469.     memory_order _Order)
  470.     {   // store _Value into *_Atom
  471.     _ATOMIC_STORE(_Atom, _Value, _Order);
  472.     }
  473.  
  474. __declspec(nothrow) inline void atomic_store_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
  475.     {   // store _Value into *_Atom
  476.     _ATOMIC_STORE(_Atom, _Value, _Order);
  477.     }
  478.  
  479. __declspec(nothrow) inline void atomic_store(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  480.     {   // store _Value into *_Atom
  481.     atomic_store_explicit(_Atom, _Value, memory_order_seq_cst);
  482.     }
  483.  
  484. __declspec(nothrow) inline void atomic_store(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  485.     {   // store _Value into *_Atom
  486.     atomic_store_explicit(_Atom, _Value, memory_order_seq_cst);
  487.     }
  488.  
  489. _NODISCARD __declspec(nothrow) inline _ITYPE atomic_load_explicit(const volatile _ATOMIC_ITYPE *_Atom,
  490.         memory_order _Order)
  491.     {   // return value held in *_Atom
  492.     return (_ATOMIC_LOAD(_Atom, _Order));
  493.     }
  494.  
  495. _NODISCARD __declspec(nothrow) inline _ITYPE atomic_load_explicit(const _ATOMIC_ITYPE *_Atom, memory_order _Order)
  496.     {   // return value held in *_Atom
  497.     return (_ATOMIC_LOAD(_Atom, _Order));
  498.     }
  499.  
  500. _NODISCARD __declspec(nothrow) inline _ITYPE atomic_load(const volatile _ATOMIC_ITYPE *_Atom)
  501.     {   // return value stored in *_Atom
  502.     return (atomic_load_explicit(_Atom, memory_order_seq_cst));
  503.     }
  504.  
  505. _NODISCARD __declspec(nothrow) inline _ITYPE atomic_load(const _ATOMIC_ITYPE *_Atom)
  506.     {   // return value stored in *_Atom
  507.     return (atomic_load_explicit(_Atom, memory_order_seq_cst));
  508.     }
  509.  
  510. __declspec(nothrow) inline _ITYPE atomic_exchange_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
  511.     memory_order _Order)
  512.     {   // exchange value stored in *_Atom with _Value
  513.     return (_ATOMIC_EXCHANGE(_Atom, _Value, _Order));
  514.     }
  515.  
  516. __declspec(nothrow) inline _ITYPE atomic_exchange_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
  517.     {   // exchange value stored in *_Atom with _Value
  518.     return (_ATOMIC_EXCHANGE(_Atom, _Value, _Order));
  519.     }
  520.  
  521. __declspec(nothrow) inline _ITYPE atomic_exchange(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  522.     {   // exchange value stored in *_Atom with _Value
  523.     return (atomic_exchange_explicit(_Atom, _Value, memory_order_seq_cst));
  524.     }
  525.  
  526. __declspec(nothrow) inline _ITYPE atomic_exchange(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  527.     {   // exchange value stored in *_Atom with _Value
  528.     return (atomic_exchange_explicit(_Atom, _Value, memory_order_seq_cst));
  529.     }
  530.  
  531. __declspec(nothrow) inline bool atomic_compare_exchange_weak_explicit(
  532.     volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value,
  533.     memory_order _Order1, memory_order _Order2)
  534.     {   // compare and exchange value stored in *_Atom with *_Exp, _Value
  535.     return (_ATOMIC_COMPARE_EXCHANGE_WEAK(_Atom, _Exp, _Value,
  536.         _Order1, _Order2));
  537.     }
  538.  
  539. __declspec(nothrow) inline bool atomic_compare_exchange_weak_explicit(
  540.     _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value,
  541.     memory_order _Order1, memory_order _Order2)
  542.     {   // compare and exchange value stored in *_Atom with *_Exp, _Value
  543.     return (_ATOMIC_COMPARE_EXCHANGE_WEAK(_Atom, _Exp, _Value,
  544.         _Order1, _Order2));
  545.     }
  546.  
  547. __declspec(nothrow) inline bool atomic_compare_exchange_weak(
  548.     volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value)
  549.     {   // compare and exchange value stored in *_Atom with *_Exp, _Value
  550.     return (atomic_compare_exchange_weak_explicit(
  551.         _Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst));
  552.     }
  553.  
  554. __declspec(nothrow) inline bool atomic_compare_exchange_weak(
  555.     _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value)
  556.     {   // compare and exchange value stored in *_Atom with *_Exp, _Value
  557.     return (atomic_compare_exchange_weak_explicit(
  558.         _Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst));
  559.     }
  560.  
  561. __declspec(nothrow) inline bool atomic_compare_exchange_strong_explicit(
  562.     volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value,
  563.     memory_order _Order1, memory_order _Order2)
  564.     {   // compare and exchange value stored in *_Atom with *_Exp, _Value
  565.     return (_ATOMIC_COMPARE_EXCHANGE_STRONG(_Atom, _Exp, _Value,
  566.         _Order1, _Order2));
  567.     }
  568.  
  569. __declspec(nothrow) inline bool atomic_compare_exchange_strong_explicit(
  570.     _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value,
  571.     memory_order _Order1, memory_order _Order2)
  572.     {   // compare and exchange value stored in *_Atom with *_Exp, _Value
  573.     return (_ATOMIC_COMPARE_EXCHANGE_STRONG(_Atom, _Exp, _Value,
  574.         _Order1, _Order2));
  575.     }
  576.  
  577. __declspec(nothrow) inline bool atomic_compare_exchange_strong(
  578.     volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value)
  579.     {   // compare and exchange value stored in *_Atom with *_Exp, _Value
  580.     return (atomic_compare_exchange_strong_explicit(
  581.         _Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst));
  582.     }
  583.  
  584. __declspec(nothrow) inline bool atomic_compare_exchange_strong(
  585.     _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value)
  586.     {   // compare and exchange value stored in *_Atom with *_Exp, _Value
  587.     return (atomic_compare_exchange_strong_explicit(
  588.         _Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst));
  589.     }
  590.  
  591.         // CORE MEMBER FUNCTIONS
  592. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator=(_ITYPE _Value) volatile
  593.     {   // assign _Value to *this
  594.     atomic_store(this, _Value);
  595.     return (_Value);
  596.     }
  597.  
  598. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator=(_ITYPE _Value)
  599.     {   // assign _Value to *this
  600.     atomic_store(this, _Value);
  601.     return (_Value);
  602.     }
  603.  
  604. _NODISCARD __declspec(nothrow) inline bool _ATOMIC_ITYPE::is_lock_free() const volatile
  605.     {   // return true if operations on *this are lock-free
  606.     return (atomic_is_lock_free(this));
  607.     }
  608.  
  609. _NODISCARD __declspec(nothrow) inline bool _ATOMIC_ITYPE::is_lock_free() const
  610.     {   // return true if operations on *this are lock-free
  611.     return (atomic_is_lock_free(this));
  612.     }
  613.  
  614. __declspec(nothrow) inline void _ATOMIC_ITYPE::store(_ITYPE _Value, memory_order _Order) volatile
  615.     {   // store _Value into *this
  616.     atomic_store_explicit(this, _Value, _Order);
  617.     }
  618.  
  619. __declspec(nothrow) inline void _ATOMIC_ITYPE::store(_ITYPE _Value, memory_order _Order)
  620.     {   // store _Value into *this
  621.     atomic_store_explicit(this, _Value, _Order);
  622.     }
  623.  
  624. _NODISCARD __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::load(memory_order _Order) const volatile
  625.     {   // return value held in *this
  626.     return (atomic_load_explicit(this, _Order));
  627.     }
  628.  
  629. _NODISCARD __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::load(memory_order _Order) const
  630.     {   // return value held in *this
  631.     return (atomic_load_explicit(this, _Order));
  632.     }
  633.  
  634. #ifndef _ATOMIC_IS_ADDRESS_TYPE
  635. __declspec(nothrow) inline _ATOMIC_ITYPE::operator _ITYPE() const volatile
  636.     {   // return value held in *this
  637.     return (atomic_load(this));
  638.     }
  639.  
  640. __declspec(nothrow) inline _ATOMIC_ITYPE::operator _ITYPE() const
  641.     {   // return value held in *this
  642.     return (atomic_load(this));
  643.     }
  644. #endif // _ATOMIC_IS_ADDRESS_TYPE
  645.  
  646. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::exchange(_ITYPE _Value, memory_order _Order) volatile
  647.     {   // exchange value stored in *this with _Value
  648.     return (atomic_exchange_explicit(this, _Value, _Order));
  649.     }
  650.  
  651. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::exchange(_ITYPE _Value, memory_order _Order)
  652.     {   // exchange value stored in *this with _Value
  653.     return (atomic_exchange_explicit(this, _Value, _Order));
  654.     }
  655.  
  656. __declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_weak(
  657.     _ITYPE& _Exp, _ITYPE _Value,
  658.     memory_order _Order1, memory_order _Order2) volatile
  659.     {   // compare and exchange value stored in *this with *_Exp, _Value
  660.     return (atomic_compare_exchange_weak_explicit(
  661.         this, &_Exp, _Value, _Order1, _Order2));
  662.     }
  663.  
  664. __declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_weak(
  665.     _ITYPE& _Exp, _ITYPE _Value,
  666.     memory_order _Order1, memory_order _Order2)
  667.     {   // compare and exchange value stored in *this with *_Exp, _Value
  668.     return (atomic_compare_exchange_weak_explicit(
  669.         this, &_Exp, _Value, _Order1, _Order2));
  670.     }
  671.  
  672. __declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_weak(
  673.     _ITYPE& _Exp, _ITYPE _Value,
  674.     memory_order _Order) volatile
  675.     {   // compare and exchange value stored in *this with *_Exp, _Value
  676.     return (atomic_compare_exchange_weak_explicit(
  677.         this, &_Exp, _Value, _Order, _Get_memory_order(_Order)));
  678.     }
  679.  
  680. __declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_weak(
  681.     _ITYPE& _Exp, _ITYPE _Value,
  682.     memory_order _Order)
  683.     {   // compare and exchange value stored in *this with *_Exp, _Value
  684.     return (atomic_compare_exchange_weak_explicit(
  685.         this, &_Exp, _Value, _Order, _Get_memory_order(_Order)));
  686.     }
  687.  
  688. __declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_strong(
  689.     _ITYPE& _Exp, _ITYPE _Value,
  690.     memory_order _Order1, memory_order _Order2) volatile
  691.     {   // compare and exchange value stored in *this with *_Exp, _Value
  692.     return (atomic_compare_exchange_strong_explicit(
  693.         this, &_Exp, _Value, _Order1, _Order2));
  694.     }
  695.  
  696. __declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_strong(
  697.     _ITYPE& _Exp, _ITYPE _Value,
  698.     memory_order _Order1, memory_order _Order2)
  699.     {   // compare and exchange value stored in *this with *_Exp, _Value
  700.     return (atomic_compare_exchange_strong_explicit(
  701.         this, &_Exp, _Value, _Order1, _Order2));
  702.     }
  703.  
  704. __declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_strong(
  705.     _ITYPE& _Exp, _ITYPE _Value,
  706.     memory_order _Order) volatile
  707.     {   // compare and exchange value stored in *this with *_Exp, _Value
  708.     return (atomic_compare_exchange_strong_explicit(
  709.         this, &_Exp, _Value, _Order, _Get_memory_order(_Order)));
  710.     }
  711.  
  712. __declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_strong(
  713.     _ITYPE& _Exp, _ITYPE _Value,
  714.     memory_order _Order)
  715.     {   // compare and exchange value stored in *this with *_Exp, _Value
  716.     return (atomic_compare_exchange_strong_explicit(
  717.         this, &_Exp, _Value, _Order, _Get_memory_order(_Order)));
  718.     }
  719.  
  720.         // SPECIALIZATIONS OF GENERAL OPERATIONS ON ATOMIC TYPES
  721.  #ifndef _ATOMIC_HAS_NO_SPECIALIZATION
  722. template<>
  723.     _NODISCARD __declspec(nothrow) inline bool atomic_is_lock_free(const volatile atomic<_ITYPE> *_Atom)
  724.     {
  725.     return (atomic_is_lock_free(
  726.         static_cast<const volatile _ATOMIC_ITYPE *>(_Atom)));
  727.     }
  728.  
  729. template<>
  730.     _NODISCARD __declspec(nothrow) inline bool atomic_is_lock_free(const atomic<_ITYPE> *_Atom)
  731.     {
  732.     return (atomic_is_lock_free(static_cast<const _ATOMIC_ITYPE *>(_Atom)));
  733.     }
  734.  
  735. template<>
  736.     __declspec(nothrow) inline void atomic_init(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
  737.     {
  738.     atomic_init(static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value);
  739.     }
  740.  
  741. template<>
  742.     __declspec(nothrow) inline void atomic_init(atomic<_ITYPE> *_Atom, _ITYPE _Value)
  743.     {
  744.     atomic_init(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value);
  745.     }
  746.  
  747. template<>
  748.     __declspec(nothrow) inline void atomic_store(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
  749.     {
  750.     atomic_store(static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value);
  751.     }
  752.  
  753. template<>
  754.     __declspec(nothrow) inline void atomic_store(atomic<_ITYPE> *_Atom, _ITYPE _Value)
  755.     {
  756.     atomic_store(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value);
  757.     }
  758.  
  759. template<>
  760.     __declspec(nothrow) inline void atomic_store_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
  761.         memory_order _Order)
  762.     {
  763.     atomic_store_explicit(static_cast<volatile _ATOMIC_ITYPE *>(_Atom),
  764.         _Value, _Order);
  765.     }
  766.  
  767. template<>
  768.     __declspec(nothrow) inline void atomic_store_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value, memory_order _Order)
  769.     {
  770.     atomic_store_explicit(static_cast<_ATOMIC_ITYPE *>(_Atom),
  771.         _Value, _Order);
  772.     }
  773.  
  774. template<>
  775.     _NODISCARD __declspec(nothrow) inline _ITYPE atomic_load(const volatile atomic<_ITYPE> *_Atom)
  776.     {
  777.     return (atomic_load(static_cast<const volatile _ATOMIC_ITYPE *>(_Atom)));
  778.     }
  779.  
  780. template<>
  781.     _NODISCARD __declspec(nothrow) inline _ITYPE atomic_load(const atomic<_ITYPE> *_Atom)
  782.     {
  783.     return (atomic_load(static_cast<const volatile _ATOMIC_ITYPE *>(_Atom)));
  784.     }
  785.  
  786. template<>
  787.     _NODISCARD __declspec(nothrow) inline _ITYPE atomic_load_explicit(const volatile atomic<_ITYPE> *_Atom,
  788.         memory_order _Order)
  789.     {
  790.     return (atomic_load_explicit(
  791.         static_cast<const volatile _ATOMIC_ITYPE *>(_Atom), _Order));
  792.     }
  793.  
  794. template<>
  795.     _NODISCARD __declspec(nothrow) inline _ITYPE atomic_load_explicit(const atomic<_ITYPE> *_Atom, memory_order _Order)
  796.     {
  797.     return (atomic_load_explicit(
  798.         static_cast<const _ATOMIC_ITYPE *>(_Atom), _Order));
  799.     }
  800.  
  801. template<>
  802.     __declspec(nothrow) inline _ITYPE atomic_exchange(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
  803.     {
  804.     return (atomic_exchange(
  805.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
  806.     }
  807.  
  808. template<>
  809.     __declspec(nothrow) inline _ITYPE atomic_exchange(atomic<_ITYPE> *_Atom, _ITYPE _Value)
  810.     {
  811.     return (atomic_exchange(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
  812.     }
  813.  
  814. template<>
  815.     __declspec(nothrow) inline _ITYPE atomic_exchange_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
  816.         memory_order _Order)
  817.     {
  818.     return (atomic_exchange_explicit(
  819.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
  820.     }
  821.  
  822. template<>
  823.     __declspec(nothrow) inline _ITYPE atomic_exchange_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
  824.         memory_order _Order)
  825.     {
  826.     return (atomic_exchange_explicit(static_cast<_ATOMIC_ITYPE *>(_Atom),
  827.         _Value, _Order));
  828.     }
  829.  
  830. template<>
  831.     __declspec(nothrow) inline bool atomic_compare_exchange_weak(
  832.         volatile atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value)
  833.     {
  834.     return (atomic_compare_exchange_weak(
  835.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp, _Value));
  836.     }
  837.  
  838. template<>
  839.     __declspec(nothrow) inline bool atomic_compare_exchange_weak(
  840.         atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value)
  841.     {
  842.     return (atomic_compare_exchange_weak(
  843.         static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value));
  844.     }
  845.  
  846. template<>
  847.     __declspec(nothrow) inline bool atomic_compare_exchange_weak_explicit(
  848.         volatile atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value,
  849.         memory_order _Order1, memory_order _Order2)
  850.     {
  851.     return (atomic_compare_exchange_weak_explicit(
  852.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp,
  853.             _Value, _Order1, _Order2));
  854.     }
  855.  
  856. template<>
  857.     __declspec(nothrow) inline bool atomic_compare_exchange_weak_explicit(
  858.         atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value,
  859.         memory_order _Order1, memory_order _Order2)
  860.     {
  861.     return (atomic_compare_exchange_weak_explicit(
  862.         static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value, _Order1, _Order2));
  863.     }
  864.  
  865. template<>
  866.     __declspec(nothrow) inline bool atomic_compare_exchange_strong(
  867.         volatile atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value)
  868.     {
  869.     return (atomic_compare_exchange_strong(
  870.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp, _Value));
  871.     }
  872.  
  873. template<>
  874.     __declspec(nothrow) inline bool atomic_compare_exchange_strong(
  875.         atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value)
  876.     {
  877.     return (atomic_compare_exchange_strong(
  878.         static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value));
  879.     }
  880.  
  881. template<>
  882.     __declspec(nothrow) inline bool atomic_compare_exchange_strong_explicit(
  883.         volatile atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value,
  884.         memory_order _Order1, memory_order _Order2)
  885.     {
  886.     return (atomic_compare_exchange_strong_explicit(
  887.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp,
  888.             _Value, _Order1, _Order2));
  889.     }
  890.  
  891. template<>
  892.     __declspec(nothrow) inline bool atomic_compare_exchange_strong_explicit(
  893.         atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value,
  894.         memory_order _Order1, memory_order _Order2)
  895.     {
  896.     return (atomic_compare_exchange_strong_explicit(
  897.         static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value, _Order1, _Order2));
  898.     }
  899.  #endif /* _ATOMIC_HAS_NO_SPECIALIZATION */
  900.  
  901.  #ifdef _ATOMIC_HAS_ARITHMETIC_OPS
  902.         // ARITHMETIC NON-MEMBER FUNCTIONS
  903. __declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(
  904.     volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
  905.     {   // add _Value to value stored in *_Atom
  906.     return (_ATOMIC_FETCH_ADD(_Atom, _Value, _Order));
  907.     }
  908.  
  909. __declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(
  910.     _ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
  911.     {   // add _Value to value stored in *_Atom
  912.     return (_ATOMIC_FETCH_ADD(_Atom, _Value, _Order));
  913.     }
  914.  
  915. __declspec(nothrow) inline _ITYPE atomic_fetch_add(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  916.     {   // add _Value to value stored in *_Atom
  917.     return (atomic_fetch_add_explicit(_Atom, _Value, memory_order_seq_cst));
  918.     }
  919.  
  920. __declspec(nothrow) inline _ITYPE atomic_fetch_add(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  921.     {   // add _Value to value stored in *_Atom
  922.     return (atomic_fetch_add_explicit(_Atom, _Value, memory_order_seq_cst));
  923.     }
  924.  
  925. __declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
  926.     memory_order _Order)
  927.     {   // subtract _Value from value stored in *_Atom
  928.     return (_ATOMIC_FETCH_SUB(_Atom, _Value, _Order));
  929.     }
  930.  
  931. __declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
  932.     {   // subtract _Value from value stored in *_Atom
  933.     return (_ATOMIC_FETCH_SUB(_Atom, _Value, _Order));
  934.     }
  935.  
  936. __declspec(nothrow) inline _ITYPE atomic_fetch_sub(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  937.     {   // subtract _Value from value stored in *_Atom
  938.     return (atomic_fetch_sub_explicit(_Atom, _Value, memory_order_seq_cst));
  939.     }
  940.  
  941. __declspec(nothrow) inline _ITYPE atomic_fetch_sub(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  942.     {   // subtract _Value from value stored in *_Atom
  943.     return (atomic_fetch_sub_explicit(_Atom, _Value, memory_order_seq_cst));
  944.     }
  945.  
  946. __declspec(nothrow) inline _ITYPE atomic_fetch_and_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
  947.     memory_order _Order)
  948.     {   // and _Value with value stored in *_Atom
  949.     return (_ATOMIC_FETCH_AND(_Atom, _Value, _Order));
  950.     }
  951.  
  952. __declspec(nothrow) inline _ITYPE atomic_fetch_and_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
  953.     {   // and _Value with value stored in *_Atom
  954.     return (_ATOMIC_FETCH_AND(_Atom, _Value, _Order));
  955.     }
  956.  
  957. __declspec(nothrow) inline _ITYPE atomic_fetch_and(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  958.     {   // and _Value with value stored in *_Atom
  959.     return (atomic_fetch_and_explicit(_Atom, _Value, memory_order_seq_cst));
  960.     }
  961.  
  962. __declspec(nothrow) inline _ITYPE atomic_fetch_and(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  963.     {   // and _Value with value stored in *_Atom
  964.     return (atomic_fetch_and_explicit(_Atom, _Value, memory_order_seq_cst));
  965.     }
  966.  
  967. __declspec(nothrow) inline _ITYPE atomic_fetch_or_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
  968.     memory_order _Order)
  969.     {   // or _Value with value stored in *_Atom
  970.     return (_ATOMIC_FETCH_OR(_Atom, _Value, _Order));
  971.     }
  972.  
  973. __declspec(nothrow) inline _ITYPE atomic_fetch_or_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
  974.     {   // or _Value with value stored in *_Atom
  975.     return (_ATOMIC_FETCH_OR(_Atom, _Value, _Order));
  976.     }
  977.  
  978. __declspec(nothrow) inline _ITYPE atomic_fetch_or(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  979.     {   // or _Value with value stored in *_Atom
  980.     return (atomic_fetch_or_explicit(_Atom, _Value, memory_order_seq_cst));
  981.     }
  982.  
  983. __declspec(nothrow) inline _ITYPE atomic_fetch_or(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  984.     {   // or _Value with value stored in *_Atom
  985.     return (atomic_fetch_or_explicit(_Atom, _Value, memory_order_seq_cst));
  986.     }
  987.  
  988. __declspec(nothrow) inline _ITYPE atomic_fetch_xor_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
  989.     memory_order _Order)
  990.     {   // xor _Value with value stored in *_Atom
  991.     return (_ATOMIC_FETCH_XOR(_Atom, _Value, _Order));
  992.     }
  993.  
  994. __declspec(nothrow) inline _ITYPE atomic_fetch_xor_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
  995.     {   // xor _Value with value stored in *_Atom
  996.     return (_ATOMIC_FETCH_XOR(_Atom, _Value, _Order));
  997.     }
  998.  
  999. __declspec(nothrow) inline _ITYPE atomic_fetch_xor(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  1000.     {   // xor _Value with value stored in *_Atom
  1001.     return (atomic_fetch_xor_explicit(_Atom, _Value, memory_order_seq_cst));
  1002.     }
  1003.  
  1004. __declspec(nothrow) inline _ITYPE atomic_fetch_xor(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
  1005.     {   // xor _Value with value stored in *_Atom
  1006.     return (atomic_fetch_xor_explicit(_Atom, _Value, memory_order_seq_cst));
  1007.     }
  1008.  
  1009.         // ARITHMETIC MEMBER FUNCTIONS
  1010. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator++(int) volatile
  1011.     {   // increment value stored in *this
  1012.     return (atomic_fetch_add(this, 1));
  1013.     }
  1014.  
  1015. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator++(int)
  1016.     {   // increment value stored in *this
  1017.     return (atomic_fetch_add(this, 1));
  1018.     }
  1019.  
  1020. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator--(int) volatile
  1021.     {   // decrement value stored in *this
  1022.     return (atomic_fetch_sub(this, 1));
  1023.     }
  1024.  
  1025. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator--(int)
  1026.     {   // decrement value stored in *this
  1027.     return (atomic_fetch_sub(this, 1));
  1028.     }
  1029.  
  1030. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator++() volatile
  1031.     {   // increment value stored in *this
  1032.     return (atomic_fetch_add(this, 1) + 1);
  1033.     }
  1034.  
  1035. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator++()
  1036.     {   // increment value stored in *this
  1037.     return (atomic_fetch_add(this, 1) + 1);
  1038.     }
  1039.  
  1040. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator--() volatile
  1041.     {   // decrement value stored in *this
  1042.     return (atomic_fetch_sub(this, 1) - 1);
  1043.     }
  1044.  
  1045. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator--()
  1046.     {   // decrement value stored in *this
  1047.     return (atomic_fetch_sub(this, 1) - 1);
  1048.     }
  1049.  
  1050. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator+=(_ITYPE _Right) volatile
  1051.     {   // add _Right to value stored in *this
  1052.     return (atomic_fetch_add(this, _Right) + _Right);
  1053.     }
  1054.  
  1055. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator+=(_ITYPE _Right)
  1056.     {   // add _Right to value stored in *this
  1057.     return (atomic_fetch_add(this, _Right) + _Right);
  1058.     }
  1059.  
  1060. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator-=(_ITYPE _Right) volatile
  1061.     {   // subtract _Right from value stored in *this
  1062.     return (atomic_fetch_sub(this, _Right) - _Right);
  1063.     }
  1064.  
  1065. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator-=(_ITYPE _Right)
  1066.     {   // subtract _Right from value stored in *this
  1067.     return (atomic_fetch_sub(this, _Right) - _Right);
  1068.     }
  1069.  
  1070. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator&=(_ITYPE _Right) volatile
  1071.     {   // and _Right with value stored in *this
  1072.     return (atomic_fetch_and(this, _Right) & _Right);
  1073.     }
  1074.  
  1075. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator&=(_ITYPE _Right)
  1076.     {   // and _Right with value stored in *this
  1077.     return (atomic_fetch_and(this, _Right) & _Right);
  1078.     }
  1079.  
  1080. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator|=(_ITYPE _Right) volatile
  1081.     {   // or _Right with value stored in *this
  1082.     return (atomic_fetch_or(this, _Right) | _Right);
  1083.     }
  1084.  
  1085. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator|=(_ITYPE _Right)
  1086.     {   // or _Right with value stored in *this
  1087.     return (atomic_fetch_or(this, _Right) | _Right);
  1088.     }
  1089.  
  1090. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator^=(_ITYPE _Right) volatile
  1091.     {   // xor _Right with value stored in *this
  1092.     return (atomic_fetch_xor(this, _Right) ^ _Right);
  1093.     }
  1094.  
  1095. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator^=(_ITYPE _Right)
  1096.     {   // xor _Right with value stored in *this
  1097.     return (atomic_fetch_xor(this, _Right) ^ _Right);
  1098.     }
  1099.  
  1100. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_add(_ITYPE _Value, memory_order _Order) volatile
  1101.     {   // add _Value to value stored in *this
  1102.     return (atomic_fetch_add_explicit(this, _Value, _Order));
  1103.     }
  1104.  
  1105. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_add(_ITYPE _Value, memory_order _Order)
  1106.     {   // add _Value to value stored in *this
  1107.     return (atomic_fetch_add_explicit(this, _Value, _Order));
  1108.     }
  1109.  
  1110. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_sub(_ITYPE _Value, memory_order _Order) volatile
  1111.     {   // subtract _Value from value stored in *this
  1112.     return (atomic_fetch_sub_explicit(this, _Value, _Order));
  1113.     }
  1114.  
  1115. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_sub(_ITYPE _Value, memory_order _Order)
  1116.     {   // subtract _Value from value stored in *this
  1117.     return (atomic_fetch_sub_explicit(this, _Value, _Order));
  1118.     }
  1119.  
  1120. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_and(_ITYPE _Value, memory_order _Order) volatile
  1121.     {   // and _Value with value stored in *this
  1122.     return (atomic_fetch_and_explicit(this, _Value, _Order));
  1123.     }
  1124.  
  1125. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_and(_ITYPE _Value, memory_order _Order)
  1126.     {   // and _Value with value stored in *this
  1127.     return (atomic_fetch_and_explicit(this, _Value, _Order));
  1128.     }
  1129.  
  1130. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_or(_ITYPE _Value, memory_order _Order) volatile
  1131.     {   // or _Value with value stored in *this
  1132.     return (atomic_fetch_or_explicit(this, _Value, _Order));
  1133.     }
  1134.  
  1135. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_or(_ITYPE _Value, memory_order _Order)
  1136.     {   // or _Value with value stored in *this
  1137.     return (atomic_fetch_or_explicit(this, _Value, _Order));
  1138.     }
  1139.  
  1140. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_xor(_ITYPE _Value, memory_order _Order) volatile
  1141.     {   // xor _Value with value stored in *this
  1142.     return (atomic_fetch_xor_explicit(this, _Value, _Order));
  1143.     }
  1144.  
  1145. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_xor(_ITYPE _Value, memory_order _Order)
  1146.     {   // xor _Value with value stored in *this
  1147.     return (atomic_fetch_xor_explicit(this, _Value, _Order));
  1148.     }
  1149.  
  1150.     // SPECIALIZATIONS OF ARITHMETIC OPERATIONS ON ATOMIC TYPES
  1151.  #ifndef _ATOMIC_HAS_NO_SPECIALIZATION
  1152. template<>
  1153.     __declspec(nothrow) inline _ITYPE atomic_fetch_add(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
  1154.     {
  1155.     return (atomic_fetch_add(
  1156.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
  1157.     }
  1158.  
  1159. template<>
  1160.     __declspec(nothrow) inline _ITYPE atomic_fetch_add(atomic<_ITYPE> *_Atom, _ITYPE _Value)
  1161.     {
  1162.     return (atomic_fetch_add(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
  1163.     }
  1164.  
  1165. template<>
  1166.     __declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
  1167.         memory_order _Order)
  1168.     {
  1169.     return (atomic_fetch_add_explicit(
  1170.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
  1171.     }
  1172.  
  1173. template<>
  1174.     __declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
  1175.         memory_order _Order)
  1176.     {
  1177.     return (atomic_fetch_add_explicit(
  1178.         static_cast<_ATOMIC_ITYPE *>(_Atom), _Value, _Order));
  1179.     }
  1180.  
  1181. template<>
  1182.     __declspec(nothrow) inline _ITYPE atomic_fetch_sub(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
  1183.     {
  1184.     return (atomic_fetch_sub(
  1185.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
  1186.     }
  1187.  
  1188. template<>
  1189.     __declspec(nothrow) inline _ITYPE atomic_fetch_sub(atomic<_ITYPE> *_Atom, _ITYPE _Value)
  1190.     {
  1191.     return (atomic_fetch_sub(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
  1192.     }
  1193.  
  1194. template<>
  1195.     __declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
  1196.         memory_order _Order)
  1197.     {
  1198.     return (atomic_fetch_sub_explicit(
  1199.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
  1200.     }
  1201.  
  1202. template<>
  1203.     __declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
  1204.         memory_order _Order)
  1205.     {
  1206.     return (atomic_fetch_sub_explicit(
  1207.         static_cast<_ATOMIC_ITYPE *>(_Atom), _Value, _Order));
  1208.     }
  1209.  
  1210. template<>
  1211.     __declspec(nothrow) inline _ITYPE atomic_fetch_and(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
  1212.     {
  1213.     return (atomic_fetch_and(
  1214.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
  1215.     }
  1216.  
  1217. template<>
  1218.     __declspec(nothrow) inline _ITYPE atomic_fetch_and(atomic<_ITYPE> *_Atom, _ITYPE _Value)
  1219.     {
  1220.     return (atomic_fetch_and(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
  1221.     }
  1222.  
  1223. template<>
  1224.     __declspec(nothrow) inline _ITYPE atomic_fetch_and_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
  1225.         memory_order _Order)
  1226.     {
  1227.     return (atomic_fetch_and_explicit(
  1228.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
  1229.     }
  1230.  
  1231. template<>
  1232.     __declspec(nothrow) inline _ITYPE atomic_fetch_and_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
  1233.         memory_order _Order)
  1234.     {
  1235.     return (atomic_fetch_and_explicit(
  1236.         static_cast<_ATOMIC_ITYPE *>(_Atom), _Value, _Order));
  1237.     }
  1238.  
  1239. template<>
  1240.     __declspec(nothrow) inline _ITYPE atomic_fetch_or(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
  1241.     {
  1242.     return (atomic_fetch_or(
  1243.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
  1244.     }
  1245.  
  1246. template<>
  1247.     __declspec(nothrow) inline _ITYPE atomic_fetch_or(atomic<_ITYPE> *_Atom, _ITYPE _Value)
  1248.     {
  1249.     return (atomic_fetch_or(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
  1250.     }
  1251.  
  1252. template<>
  1253.     __declspec(nothrow) inline _ITYPE atomic_fetch_or_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
  1254.         memory_order _Order)
  1255.     {
  1256.     return (atomic_fetch_or_explicit(
  1257.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
  1258.     }
  1259.  
  1260. template<>
  1261.     __declspec(nothrow) inline _ITYPE atomic_fetch_or_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
  1262.         memory_order _Order)
  1263.     {
  1264.     return (atomic_fetch_or_explicit(
  1265.         static_cast<_ATOMIC_ITYPE *>(_Atom), _Value, _Order));
  1266.     }
  1267.  
  1268. template<>
  1269.     __declspec(nothrow) inline _ITYPE atomic_fetch_xor(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
  1270.     {
  1271.     return (atomic_fetch_xor(
  1272.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
  1273.     }
  1274.  
  1275. template<>
  1276.     __declspec(nothrow) inline _ITYPE atomic_fetch_xor(atomic<_ITYPE> *_Atom, _ITYPE _Value)
  1277.     {
  1278.     return (atomic_fetch_xor(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
  1279.     }
  1280.  
  1281. template<>
  1282.     __declspec(nothrow) inline _ITYPE atomic_fetch_xor_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
  1283.         memory_order _Order)
  1284.     {
  1285.     return (atomic_fetch_xor_explicit(
  1286.         static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
  1287.     }
  1288.  
  1289. template<>
  1290.     __declspec(nothrow) inline _ITYPE atomic_fetch_xor_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
  1291.         memory_order _Order)
  1292.     {
  1293.     return (atomic_fetch_xor_explicit(
  1294.         static_cast<_ATOMIC_ITYPE *>(_Atom), _Value, _Order));
  1295.     }
  1296.  #endif /* _ATOMIC_HAS_NO_SPECIALIZATION */
  1297.  #endif /* _ATOMIC_HAS_ARITHMETIC_OPS */
  1298.  
  1299.  #ifdef _ATOMIC_IS_ADDRESS_TYPE
  1300.         // ADDRESS NON-MEMBER FUNCTIONS
  1301. __declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(volatile _ATOMIC_ITYPE *_Atom, ptrdiff_t _Value,
  1302.     memory_order _Order)
  1303.     {   // add _Value to value stored in *_Atom
  1304.     return ((_ITYPE)_ATOMIC_FETCH_ADD(_Atom, _Value, _Order));
  1305.     }
  1306.  
  1307. __declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(_ATOMIC_ITYPE *_Atom, ptrdiff_t _Value,
  1308.     memory_order _Order)
  1309.     {   // add _Value to value stored in *_Atom
  1310.     return ((_ITYPE)_ATOMIC_FETCH_ADD(_Atom, _Value, _Order));
  1311.     }
  1312.  
  1313. __declspec(nothrow) inline _ITYPE atomic_fetch_add(volatile _ATOMIC_ITYPE *_Atom, ptrdiff_t _Value)
  1314.     {   // add _Value to value stored in *_Atom
  1315.     return (atomic_fetch_add_explicit(_Atom, _Value, memory_order_seq_cst));
  1316.     }
  1317.  
  1318. __declspec(nothrow) inline _ITYPE atomic_fetch_add(_ATOMIC_ITYPE *_Atom, ptrdiff_t _Value)
  1319.     {   // add _Value to value stored in *_Atom
  1320.     return (atomic_fetch_add_explicit(_Atom, _Value, memory_order_seq_cst));
  1321.     }
  1322.  
  1323. __declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(volatile _ATOMIC_ITYPE *_Atom, ptrdiff_t _Value,
  1324.     memory_order _Order)
  1325.     {   // subtract _Value from value stored in *_Atom
  1326.     return ((_ITYPE)_ATOMIC_FETCH_SUB(_Atom, _Value, _Order));
  1327.     }
  1328.  
  1329. __declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(_ATOMIC_ITYPE *_Atom, ptrdiff_t _Value,
  1330.     memory_order _Order)
  1331.     {   // subtract _Value from value stored in *_Atom
  1332.     return ((_ITYPE)_ATOMIC_FETCH_SUB(_Atom, _Value, _Order));
  1333.     }
  1334.  
  1335. __declspec(nothrow) inline _ITYPE atomic_fetch_sub(volatile _ATOMIC_ITYPE *_Atom, ptrdiff_t _Value)
  1336.     {   // subtract _Value from value stored in *_Atom
  1337.     return (atomic_fetch_sub_explicit(_Atom, _Value, memory_order_seq_cst));
  1338.     }
  1339.  
  1340. __declspec(nothrow) inline _ITYPE atomic_fetch_sub(_ATOMIC_ITYPE *_Atom, ptrdiff_t _Value)
  1341.     {   // subtract _Value from value stored in *_Atom
  1342.     return (atomic_fetch_sub_explicit(_Atom, _Value, memory_order_seq_cst));
  1343.     }
  1344.  
  1345.         // ADDRESS MEMBER FUNCTIONS
  1346. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_add(ptrdiff_t _Value, memory_order _Order) volatile
  1347.     {   // add _Value to value stored in *this
  1348.     return (atomic_fetch_add_explicit(this, _Value, _Order));
  1349.     }
  1350.  
  1351. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_add(ptrdiff_t _Value, memory_order _Order)
  1352.     {   // add _Value to value stored in *this
  1353.     return (atomic_fetch_add_explicit(this, _Value, _Order));
  1354.     }
  1355.  
  1356. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_sub(ptrdiff_t _Value, memory_order _Order) volatile
  1357.     {   // subtract _Value from value stored in *this
  1358.     return (atomic_fetch_sub_explicit(this, _Value, _Order));
  1359.     }
  1360.  
  1361. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_sub(ptrdiff_t _Value, memory_order _Order)
  1362.     {   // subtract _Value from value stored in *this
  1363.     return (atomic_fetch_sub_explicit(this, _Value, _Order));
  1364.     }
  1365.  
  1366. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator+=(ptrdiff_t _Right) volatile
  1367.     {   // add _Right to value stored in *this
  1368.     return ((char*)fetch_add(_Right) + _Right);
  1369.     }
  1370.  
  1371. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator+=(ptrdiff_t _Right)
  1372.     {   // add _Right to value stored in *this
  1373.     return ((char*)fetch_add(_Right) + _Right);
  1374.     }
  1375.  
  1376. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator-=(ptrdiff_t _Right) volatile
  1377.     {   // subtract _Right from value stored in *this
  1378.     return ((char*)fetch_sub(_Right) - _Right);
  1379.     }
  1380.  
  1381. __declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator-=(ptrdiff_t _Right)
  1382.     {   // subtract _Right from value stored in *this
  1383.     return ((char*)fetch_sub(_Right) - _Right);
  1384.     }
  1385.  #endif /* _ATOMIC_IS_ADDRESS_TYPE */
  1386.  
  1387. #undef _ATOMIC_FETCH_XOR
  1388. #undef _ATOMIC_FETCH_OR
  1389. #undef _ATOMIC_FETCH_AND
  1390. #undef _ATOMIC_FETCH_SUB
  1391. #undef _ATOMIC_FETCH_ADD
  1392. #undef _ATOMIC_COMPARE_EXCHANGE_STRONG
  1393. #undef _ATOMIC_COMPARE_EXCHANGE_WEAK
  1394. #undef _ATOMIC_EXCHANGE
  1395. #undef _ATOMIC_LOAD
  1396. #undef _ATOMIC_STORE
  1397. #undef _ATOMIC_LOCKING_PRIMITIVE_NAME
  1398. #undef _ATOMIC_LOCK_FREE_PRIMITIVE_NAME
  1399. #undef _ATOMIC_UINT
  1400.  
  1401. #undef _ATOMIC_IS_ADDRESS_TYPE
  1402. #undef _ATOMIC_HAS_NO_SPECIALIZATION
  1403. #undef _ATOMIC_HAS_ARITHMETIC_OPS
  1404. #undef _ISIZE
  1405. #undef _ITYPE
  1406. #undef _ATOMIC_ITYPE
  1407.  
  1408. /*
  1409.  * Copyright (c) by P.J. Plauger. All rights reserved.
  1410.  * Consult your license regarding permissions and restrictions.
  1411. V6.50:0009 */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!