{-# LANGUAGE CPP #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UnboxedTuples #-}
#if __GLASGOW_HASKELL__ < 800
{-# OPTIONS_GHC -fno-warn-orphans #-}
#endif
-- |
-- Module      : Data.Prim.Atomic
-- Copyright   : (c) Alexey Kuleshevich 2020
-- License     : BSD3
-- Maintainer  : Alexey Kuleshevich <alexey@kuleshevi.ch>
-- Stability   : experimental
-- Portability : non-portable
--
module Data.Prim.Atomic
  ( Atomic(..)
  , AtomicBits(..)
  , AtomicCount(..)
  , atomicBoolModifyMutableByteArray#
  , atomicBoolModifyFetchOldMutableByteArray#
  , atomicModifyMutableByteArray_#
  , atomicModifyFetchOldMutableByteArray#
  , atomicModifyFetchNewMutableByteArray#
  , atomicModifyOffAddr_#
  , atomicBoolModifyOffAddr#
  , atomicModifyFetchOldOffAddr#
  , atomicModifyFetchNewOffAddr#
  , atomicNotFetchOldMutableByteArray#
  , atomicNotFetchNewMutableByteArray#
  , atomicNotFetchOldOffAddr#
  , atomicNotFetchNewOffAddr#
  ) where

import Control.Prim.Monad.Unsafe
import Data.Bits
import Data.Char
import Data.Functor.Identity
import Data.Monoid
import Data.Prim.Class
import Foreign.C.Error (Errno(..))
import Foreign.Prim hiding (Any)
import GHC.Conc
import GHC.IO.Device
import System.IO
#if __GLASGOW_HASKELL__ >= 800
import Data.Functor.Const
import Data.Semigroup
#endif /* __GLASGOW_HASKELL__ >= 800 */

#include "MachDeps.h"

class (Prim a, Eq a) => Atomic a where
  -- | Read an element from `MutableByteArray#` atomically. Implies full memory barrier.
  atomicReadMutableByteArray# ::
       MutableByteArray# s -- ^ Mutable array to read the element from
    -> Int# -- ^ Offset into the array in number of elements
    -> State# s
    -> (# State# s, a #)
  atomicReadMutableByteArray# MutableByteArray# s
mba# Int#
i# State# s
s = MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readMutableByteArray# MutableByteArray# s
mba# Int#
i# (State# s -> State# s
forall s. State# s -> State# s
syncSynchronize# State# s
s)
  {-# INLINE atomicReadMutableByteArray# #-}

  -- | Write an element into `MutableByteArray#` atomically. Implies full memory barrier.
  atomicWriteMutableByteArray# ::
       MutableByteArray# s -- ^ Mutable array to write the element into
    -> Int# -- ^ Offset into the array in number of elements
    -> a -- ^ Element to write
    -> State# s
    -> State# s
  atomicWriteMutableByteArray# MutableByteArray# s
mba# Int#
i# a
a = (State# s -> State# s) -> State# s -> State# s
forall s. (State# s -> State# s) -> State# s -> State# s
withMemBarrier_# (MutableByteArray# s -> Int# -> a -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeMutableByteArray# MutableByteArray# s
mba# Int#
i# a
a)
  {-# INLINE atomicWriteMutableByteArray# #-}

  -- | Read an element from memory atomically. Implies full memory barrier.
  atomicReadOffAddr# ::
       Addr# -- ^ Pointer to the beginning of memory
    -> Int# -- ^ Offset in number of elements from the supplied pointer
    -> State# s
    -> (# State# s, a #)
  atomicReadOffAddr# Addr#
addr# Int#
i# State# s
s = Addr# -> Int# -> State# s -> (# State# s, a #)
forall a s.
Prim a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
readOffAddr# Addr#
addr# Int#
i# (State# s -> State# s
forall s. State# s -> State# s
syncSynchronize# State# s
s)
  {-# INLINE atomicReadOffAddr# #-}

  -- | Write an element directly into memory atomically. Implies full memory barrier.
  atomicWriteOffAddr# ::
       Addr# -- ^ Pointer to the beginning of memory
    -> Int# -- ^ Offset in number of elements from the supplied pointer
    -> a -- ^ Element to write
    -> State# s
    -> State# s
  atomicWriteOffAddr# Addr#
addr# Int#
i# a
a = (State# s -> State# s) -> State# s -> State# s
forall s. (State# s -> State# s) -> State# s -> State# s
withMemBarrier_# (Addr# -> Int# -> a -> State# s -> State# s
forall a s. Prim a => Addr# -> Int# -> a -> State# s -> State# s
writeOffAddr# Addr#
addr# Int#
i# a
a)
  {-# INLINE atomicWriteOffAddr# #-}

  -- | Compare-and-swap (CAS) operation. Given a mutable array, offset in number of
  -- elements, an old value and a new value atomically swap the old value for the new one,
  -- but only if the actual old value was an exact match to the expetced old one that was
  -- supplied. Returns the actual old value, which if compared to supplied expected one
  -- will tell us whether atomic swap occured or not.
  casMutableByteArray# ::
       MutableByteArray# s -- ^ Array to be mutated
    -> Int# -- ^ Offset into the array in number of elements
    -> a -- ^ Expected old value
    -> a -- ^ New value
    -> State# s -- ^ Starting state
    -> (# State# s, a #)
  default casMutableByteArray#
    :: Atomic (PrimBase a)
    => MutableByteArray# s
    -> Int#
    -> a
    -> a
    -> State# s
    -> (# State# s, a #)
  casMutableByteArray# MutableByteArray# s
mba# Int#
i# a
old a
new State# s
s =
    case MutableByteArray# s
-> Int#
-> PrimBase a
-> PrimBase a
-> State# s
-> (# State# s, PrimBase a #)
forall a s.
Atomic a =>
MutableByteArray# s
-> Int# -> a -> a -> State# s -> (# State# s, a #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
old) (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
new) State# s
s of
      (# State# s
s', PrimBase a
prev #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
prev #)
  {-# INLINE casMutableByteArray# #-}

  casOffAddr# :: Addr# -> Int# -> a -> a -> State# s -> (# State# s, a #)
  default casOffAddr# ::
    Atomic (PrimBase a) => Addr# -> Int# -> a -> a -> State# s -> (# State# s, a #)
  casOffAddr# Addr#
addr# Int#
i# a
old a
new State# s
s =
    case Addr#
-> Int#
-> PrimBase a
-> PrimBase a
-> State# s
-> (# State# s, PrimBase a #)
forall a s.
Atomic a =>
Addr# -> Int# -> a -> a -> State# s -> (# State# s, a #)
casOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
old) (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
new) State# s
s of
      (# State# s
s', PrimBase a
prev #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
prev #)
  {-# INLINE casOffAddr# #-}


  casBoolMutableByteArray# ::
       MutableByteArray# s -- ^ Array to be mutated
    -> Int# -- ^ Offset into the array in number of elements
    -> a -- ^ Expected old value
    -> a -- ^ New value
    -> State# s -- ^ Starting state
    -> (# State# s, Bool #)
  default casBoolMutableByteArray#
    :: Atomic (PrimBase a)
    => MutableByteArray# s
    -> Int#
    -> a
    -> a
    -> State# s
    -> (# State# s, Bool #)
  casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# a
old a
new State# s
s =
    case MutableByteArray# s
-> Int#
-> PrimBase a
-> PrimBase a
-> State# s
-> (# State# s, Bool #)
forall a s.
Atomic a =>
MutableByteArray# s
-> Int# -> a -> a -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
old) (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
new) State# s
s of
      (# State# s
s', Bool
casSucc #) -> (# State# s
s', Bool
casSucc #)
  {-# INLINE casBoolMutableByteArray# #-}

  casBoolOffAddr# :: Addr# -> Int# -> a -> a -> State# s -> (# State# s, Bool #)
  default casBoolOffAddr# ::
    Atomic (PrimBase a) => Addr# -> Int# -> a -> a -> State# s -> (# State# s, Bool #)
  casBoolOffAddr# Addr#
addr# Int#
i# a
old a
new State# s
s =
    case Addr#
-> Int#
-> PrimBase a
-> PrimBase a
-> State# s
-> (# State# s, Bool #)
forall a s.
Atomic a =>
Addr# -> Int# -> a -> a -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
old) (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
new) State# s
s of
      (# State# s
s', Bool
casSucc #) -> (# State# s
s', Bool
casSucc #)
  {-# INLINE casBoolOffAddr# #-}


  -- | Using `casMutableByteArray#` perform atomic modification of an element in a
  -- `MutableByteArray#`. This is essentially an implementation of a spinlock using CAS.
  --
  -- @since 0.1.0
  atomicModifyMutableByteArray# ::
       MutableByteArray# s -- ^ Array to be mutated
    -> Int# -- ^ Index in number of `Int#` elements into the `MutableByteArray#`
    -> (a -> (# a, b #)) -- ^ Function to be applied atomically to the element
    -> State# s -- ^ Starting state
    -> (# State# s, b #)
  atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# a -> (# a, b #)
f State# s
s0 =
    let go :: State# s -> a -> (# State# s, b #)
go State# s
s a
o =
          case a -> (# a, b #)
f a
o of
            (# a
n, b
artifact #) ->
              case MutableByteArray# s
-> Int# -> a -> a -> State# s -> (# State# s, a #)
forall a s.
Atomic a =>
MutableByteArray# s
-> Int# -> a -> a -> State# s -> (# State# s, a #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# a
o a
n State# s
s of
                (# State# s
s', a
o' #) ->
                  if a
o a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
o'
                    then (# State# s
s', b
artifact #)
                    else State# s -> a -> (# State# s, b #)
go State# s
s a
o'
     in case MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readMutableByteArray# MutableByteArray# s
mba# Int#
i# State# s
s0 of
          (# State# s
s', a
o #) -> State# s -> a -> (# State# s, b #)
go State# s
s' a
o
  {-# INLINE atomicModifyMutableByteArray# #-}

  -- | Using `casOffAddr#` perform atomic modification of an element in a
  -- `OffAddr#`. This is essentially an implementation of a spinlock using CAS.
  --
  -- @since 0.1.0
  atomicModifyOffAddr# ::
       Addr# -- ^ Array to be mutated
    -> Int# -- ^ Index in number of `Int#` elements into the `OffAddr#`
    -> (a -> (# a, b #)) -- ^ Function to be applied atomically to the element
    -> State# s -- ^ Starting state
    -> (# State# s, b #)
  atomicModifyOffAddr# Addr#
addr# Int#
i# a -> (# a, b #)
f State# s
s0 =
    let go :: State# s -> a -> (# State# s, b #)
go State# s
s a
o =
          case a -> (# a, b #)
f a
o of
            (# a
n, b
artifact #) ->
              case Addr# -> Int# -> a -> a -> State# s -> (# State# s, a #)
forall a s.
Atomic a =>
Addr# -> Int# -> a -> a -> State# s -> (# State# s, a #)
casOffAddr# Addr#
addr# Int#
i# a
o a
n State# s
s of
                (# State# s
s', a
o' #) ->
                  if a
o a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
o'
                    then (# State# s
s', b
artifact #)
                    else State# s -> a -> (# State# s, b #)
go State# s
s a
o'
     in case Addr# -> Int# -> State# s -> (# State# s, a #)
forall a s.
Prim a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
readOffAddr# Addr#
addr# Int#
i# State# s
s0 of
          (# State# s
s', a
o #) -> State# s -> a -> (# State# s, b #)
go State# s
s' a
o
  {-# INLINE atomicModifyOffAddr# #-}


-- | Using `casBoolMutableByteArray#` perform atomic modification of an element in a
-- `MutableByteArray#`. This is essentially an implementation of a spinlock using CAS.
--
-- @since 0.1.0
atomicBoolModifyMutableByteArray# ::
     Atomic a =>
     MutableByteArray# s -- ^ Array to be mutated
  -> Int# -- ^ Index in number of `Int#` elements into the `MutableByteArray#`
  -> (a -> (# a, b #)) -- ^ Function to be applied atomically to the element
  -> State# s -- ^ Starting state
  -> (# State# s, b #)
atomicBoolModifyMutableByteArray# :: MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicBoolModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# a -> (# a, b #)
f State# s
s0 =
  let go :: State# s -> a -> (# State# s, b #)
go State# s
s a
o =
        case a -> (# a, b #)
f a
o of
          (# a
n, b
artifact #) ->
            case MutableByteArray# s
-> Int# -> a -> a -> State# s -> (# State# s, Bool #)
forall a s.
Atomic a =>
MutableByteArray# s
-> Int# -> a -> a -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# a
o a
n State# s
s of
              (# State# s
s', Bool
isCasSucc #) ->
                if Bool
isCasSucc
                  then (# State# s
s', b
artifact #)
                  else case MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readMutableByteArray# MutableByteArray# s
mba# Int#
i# State# s
s' of
                         (# State# s
s'', a
o' #) -> State# s -> a -> (# State# s, b #)
go State# s
s'' a
o'
   in case MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readMutableByteArray# MutableByteArray# s
mba# Int#
i# State# s
s0 of
        (# State# s
s', a
o #) -> State# s -> a -> (# State# s, b #)
go State# s
s' a
o
{-# INLINE atomicBoolModifyMutableByteArray# #-}

-- | Using `casBoolMutableByteArray#` perform atomic modification of an element in a
-- `MutableByteArray#`. Returns the previous value.
--
-- @since 0.1.0
atomicBoolModifyFetchOldMutableByteArray# ::
     Atomic a =>
     MutableByteArray# s -- ^ Array to be mutated
  -> Int# -- ^ Index in number of `Int#` elements into the `MutableByteArray#`
  -> (a -> a) -- ^ Function to be applied atomically to the element
  -> State# s -- ^ Starting state
  -> (# State# s, a #)
atomicBoolModifyFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> (a -> a) -> State# s -> (# State# s, a #)
atomicBoolModifyFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# a -> a
f =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicBoolModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
a -> let a' :: a
a' = a -> a
f a
a in a -> (# a, a #) -> (# a, a #)
seq a
a' (# a
a', a
a #))
{-# INLINE atomicBoolModifyFetchOldMutableByteArray# #-}


-- | Using `casMutableByteArray#` perform atomic modification of an element in a
-- `MutableByteArray#`. Returns the previous value.
--
-- @since 0.1.0
atomicModifyFetchOldMutableByteArray# ::
     Atomic a =>
     MutableByteArray# s -- ^ Array to be mutated
  -> Int# -- ^ Index in number of `Int#` elements into the `MutableByteArray#`
  -> (a -> a) -- ^ Function to be applied atomically to the element
  -> State# s -- ^ Starting state
  -> (# State# s, a #)
atomicModifyFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> (a -> a) -> State# s -> (# State# s, a #)
atomicModifyFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# a -> a
f =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
a -> let a' :: a
a' = a -> a
f a
a in a -> (# a, a #) -> (# a, a #)
seq a
a' (# a
a', a
a #))
{-# INLINE atomicModifyFetchOldMutableByteArray# #-}


-- | Using `casMutableByteArray#` perform atomic modification of an element in a
-- `MutableByteArray#`. Returns the new value.
--
-- @since 0.1.0
atomicModifyFetchNewMutableByteArray# ::
     Atomic a =>
     MutableByteArray# s -- ^ Array to be mutated
  -> Int# -- ^ Index in number of `Int#` elements into the `MutableByteArray#`
  -> (a -> a) -- ^ Function to be applied atomically to the element
  -> State# s -- ^ Starting state
  -> (# State# s, a #)
atomicModifyFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> (a -> a) -> State# s -> (# State# s, a #)
atomicModifyFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# a -> a
f =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
a -> let a' :: a
a' = a -> a
f a
a in a -> (# a, a #) -> (# a, a #)
seq a
a' (# a
a', a
a' #))
{-# INLINE atomicModifyFetchNewMutableByteArray# #-}

-- | Using `casMutableByteArray#` perform atomic modification of an element in a
-- `MutableByteArray#`.
--
-- @since 0.1.0
atomicModifyMutableByteArray_# ::
     Atomic a =>
     MutableByteArray# s -- ^ Array to be mutated
  -> Int# -- ^ Index in number of `Int#` elements into the `MutableByteArray#`
  -> (a -> a) -- ^ Function to be applied atomically to the element
  -> State# s -- ^ Starting state
  -> State# s
atomicModifyMutableByteArray_# :: MutableByteArray# s -> Int# -> (a -> a) -> State# s -> State# s
atomicModifyMutableByteArray_# MutableByteArray# s
mba# Int#
i# a -> a
f State# s
s =
  case MutableByteArray# s
-> Int# -> (a -> (# a, () #)) -> State# s -> (# State# s, () #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
a -> let a' :: a
a' = a -> a
f a
a in a -> (# a, () #) -> (# a, () #)
seq a
a' (# a
a', () #)) State# s
s of
    (# State# s
s', () #) -> State# s
s'
{-# INLINE atomicModifyMutableByteArray_# #-}


-- | Using `casBoolOffAddr#` perform atomic modification of an element in a
-- `OffAddr#`. This is essentially an implementation of a spinlock using CAS.
--
-- @since 0.1.0
atomicBoolModifyOffAddr# ::
     Atomic a =>
     Addr# -- ^ Array to be mutated
  -> Int# -- ^ Index in number of `Int#` elements into the `OffAddr#`
  -> (a -> (# a, b #)) -- ^ Function to be applied atomically to the element
  -> State# s -- ^ Starting state
  -> (# State# s, b #)
atomicBoolModifyOffAddr# :: Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicBoolModifyOffAddr# Addr#
addr# Int#
i# a -> (# a, b #)
f State# s
s0 =
  let go :: State# s -> a -> (# State# s, b #)
go State# s
s a
o =
        case a -> (# a, b #)
f a
o of
          (# a
n, b
artifact #) ->
            case Addr# -> Int# -> a -> a -> State# s -> (# State# s, Bool #)
forall a s.
Atomic a =>
Addr# -> Int# -> a -> a -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# a
o a
n State# s
s of
              (# State# s
s', Bool
isCasSucc #) ->
                if Bool
isCasSucc
                  then (# State# s
s', b
artifact #)
                  else case Addr# -> Int# -> State# s -> (# State# s, a #)
forall a s.
Atomic a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
atomicReadOffAddr# Addr#
addr# Int#
i# State# s
s' of
                         (# State# s
s'', a
o' #) -> State# s -> a -> (# State# s, b #)
go State# s
s'' a
o'
   in case Addr# -> Int# -> State# s -> (# State# s, a #)
forall a s.
Atomic a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
atomicReadOffAddr# Addr#
addr# Int#
i# State# s
s0 of
        (# State# s
s', a
o #) -> State# s -> a -> (# State# s, b #)
go State# s
s' a
o
{-# INLINE atomicBoolModifyOffAddr# #-}


-- | Using `casOffAddr#` perform atomic modification of an element in a
-- `OffAddr#`. Returns the previous value.
--
-- @since 0.1.0
atomicModifyFetchOldOffAddr# ::
     Atomic a =>
     Addr# -- ^ Array to be mutated
  -> Int# -- ^ Index in number of `Int#` elements into the `OffAddr#`
  -> (a -> a) -- ^ Function to be applied atomically to the element
  -> State# s -- ^ Starting state
  -> (# State# s, a #)
atomicModifyFetchOldOffAddr# :: Addr# -> Int# -> (a -> a) -> State# s -> (# State# s, a #)
atomicModifyFetchOldOffAddr# Addr#
addr# Int#
i# a -> a
f =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
a -> let a' :: a
a' = a -> a
f a
a in a -> (# a, a #) -> (# a, a #)
seq a
a' (# a
a', a
a #))
{-# INLINE atomicModifyFetchOldOffAddr# #-}


-- | Using `casOffAddr#` perform atomic modification of an element in a
-- `OffAddr#`. Returns the new value.
--
-- @since 0.1.0
atomicModifyFetchNewOffAddr# ::
     Atomic a =>
     Addr# -- ^ Array to be mutated
  -> Int# -- ^ Index in number of `Int#` elements into the `OffAddr#`
  -> (a -> a) -- ^ Function to be applied atomically to the element
  -> State# s -- ^ Starting state
  -> (# State# s, a #)
atomicModifyFetchNewOffAddr# :: Addr# -> Int# -> (a -> a) -> State# s -> (# State# s, a #)
atomicModifyFetchNewOffAddr# Addr#
addr# Int#
i# a -> a
f =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
a -> let a' :: a
a' = a -> a
f a
a in a -> (# a, a #) -> (# a, a #)
seq a
a' (# a
a', a
a' #))
{-# INLINE atomicModifyFetchNewOffAddr# #-}

-- | Using `casOffAddr#` perform atomic modification of an element in a
-- `OffAddr#`.
--
-- @since 0.1.0
atomicModifyOffAddr_# ::
     Atomic a =>
     Addr# -- ^ Array to be mutated
  -> Int# -- ^ Index in number of `Int#` elements into the `OffAddr#`
  -> (a -> a) -- ^ Function to be applied atomically to the element
  -> State# s -- ^ Starting state
  -> State# s
atomicModifyOffAddr_# :: Addr# -> Int# -> (a -> a) -> State# s -> State# s
atomicModifyOffAddr_# Addr#
addr# Int#
i# a -> a
f State# s
s =
  case Addr#
-> Int# -> (a -> (# a, () #)) -> State# s -> (# State# s, () #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
a -> let a' :: a
a' = a -> a
f a
a in a -> (# a, () #) -> (# a, () #)
seq a
a' (# a
a', () #)) State# s
s of
    (# State# s
s', () #) -> State# s
s'
{-# INLINE atomicModifyOffAddr_# #-}



class Atomic a => AtomicCount a where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicAddFetchOldMutableByteArray# ::
    AtomicCount (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicCount a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}

  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicAddFetchNewMutableByteArray# ::
    AtomicCount (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicCount a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}

  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicSubFetchOldMutableByteArray# ::
    AtomicCount (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicCount a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}

  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicSubFetchNewMutableByteArray# ::
    AtomicCount (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicCount a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}


  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicAddFetchOldOffAddr# ::
    AtomicCount (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicCount a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicAddFetchOldOffAddr# #-}

  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicAddFetchNewOffAddr# ::
    AtomicCount (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicCount a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicAddFetchNewOffAddr# #-}

  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicSubFetchOldOffAddr# ::
    AtomicCount (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicCount a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicSubFetchOldOffAddr# #-}

  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicSubFetchNewOffAddr# ::
    AtomicCount (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicCount a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicSubFetchNewOffAddr# #-}



class (Bits a, Atomic a) => AtomicBits a where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicAndFetchOldMutableByteArray# ::
    AtomicBits (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}

  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicAndFetchNewMutableByteArray# ::
    AtomicBits (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}

  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicNandFetchOldMutableByteArray# ::
    AtomicBits (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}

  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicNandFetchNewMutableByteArray# ::
    AtomicBits (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}

  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicOrFetchOldMutableByteArray# ::
    AtomicBits (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}

  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicOrFetchNewMutableByteArray# ::
    AtomicBits (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}

  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicXorFetchOldMutableByteArray# ::
    AtomicBits (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}

  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicXorFetchNewMutableByteArray# ::
    AtomicBits (PrimBase a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
  atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# a
x State# s
s =
    case MutableByteArray# s
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}


  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicAndFetchOldOffAddr# ::
    AtomicBits (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicAndFetchOldOffAddr# #-}

  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicAndFetchNewOffAddr# ::
    AtomicBits (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicAndFetchNewOffAddr# #-}

  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicNandFetchOldOffAddr# ::
    AtomicBits (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicNandFetchOldOffAddr# #-}

  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicNandFetchNewOffAddr# ::
    AtomicBits (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicNandFetchNewOffAddr# #-}

  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicOrFetchOldOffAddr# ::
    AtomicBits (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicOrFetchOldOffAddr# #-}

  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicOrFetchNewOffAddr# ::
    AtomicBits (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicOrFetchNewOffAddr# #-}

  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicXorFetchOldOffAddr# ::
    AtomicBits (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicXorFetchOldOffAddr# #-}

  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  default atomicXorFetchNewOffAddr# ::
    AtomicBits (PrimBase a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
  atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# a
x State# s
s =
    case Addr#
-> Int# -> PrimBase a -> State# s -> (# State# s, PrimBase a #)
forall a s.
AtomicBits a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# (a -> PrimBase a
forall a. Prim a => a -> PrimBase a
toPrimBase a
x) State# s
s of
      (# State# s
s', PrimBase a
y #) -> (# State# s
s', PrimBase a -> a
forall a. Prim a => PrimBase a -> a
fromPrimBase PrimBase a
y #)
  {-# INLINE atomicXorFetchNewOffAddr# #-}



-- | Flip all bits atomically in the element of an array at the supplied
-- offset. Returns the previous value. Implies full memory barrier.
atomicNotFetchOldMutableByteArray# ::
  forall a s . AtomicBits a => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
atomicNotFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
atomicNotFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# =
  MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
forall a s.
AtomicBits a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> a
forall a. Bits a => a -> a
complement (a
forall a. Bits a => a
zeroBits :: a))
{-# INLINE atomicNotFetchOldMutableByteArray# #-}

-- | Flip all bits atomically in the element of an array at the supplied
-- offset. Returns the new value. Implies full memory barrier.
atomicNotFetchNewMutableByteArray# ::
  forall a s . AtomicBits a => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
atomicNotFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
atomicNotFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# =
  MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
forall a s.
AtomicBits a =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# (a -> a
forall a. Bits a => a -> a
complement (a
forall a. Bits a => a
zeroBits :: a))
{-# INLINE atomicNotFetchNewMutableByteArray# #-}


-- | Flip all bits atomically in the element of an array at the supplied
-- offset. Returns the previous value. Implies full memory barrier.
atomicNotFetchOldOffAddr# ::
  forall a s . AtomicBits a => Addr# -> Int# -> State# s -> (# State# s, a #)
atomicNotFetchOldOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, a #)
atomicNotFetchOldOffAddr# Addr#
addr# Int#
i# =
  Addr# -> Int# -> a -> State# s -> (# State# s, a #)
forall a s.
AtomicBits a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# (a -> a
forall a. Bits a => a -> a
complement (a
forall a. Bits a => a
zeroBits :: a))
{-# INLINE atomicNotFetchOldOffAddr# #-}

-- | Flip all bits atomically in the element of an array at the supplied
-- offset. Returns the new value. Implies full memory barrier.
atomicNotFetchNewOffAddr# ::
  forall a s . AtomicBits a => Addr# -> Int# -> State# s -> (# State# s, a #)
atomicNotFetchNewOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, a #)
atomicNotFetchNewOffAddr# Addr#
addr# Int#
i# =
  Addr# -> Int# -> a -> State# s -> (# State# s, a #)
forall a s.
AtomicBits a =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# (a -> a
forall a. Bits a => a -> a
complement (a
forall a. Bits a => a
zeroBits :: a))
{-# INLINE atomicNotFetchNewOffAddr# #-}



instance Atomic Int8 where
  casMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> Int8 -> State# s -> (# State# s, Int8 #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
old Int8
new = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> Int8 -> IO Int8
syncCasInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
old Int8
new)
  {-# INLINE casMutableByteArray# #-}
  casOffAddr# :: Addr# -> Int# -> Int8 -> Int8 -> State# s -> (# State# s, Int8 #)
casOffAddr# Addr#
addr# Int#
i# Int8
old Int8
new = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> Int8 -> IO Int8
syncCasInt8AddrIO Addr#
addr# Int#
i# Int8
old Int8
new)
  {-# INLINE casOffAddr# #-}
  casBoolMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> Int8 -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
old Int8
new = IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (MutableByteArray# s -> Int# -> Int8 -> Int8 -> IO CBool
forall s. MutableByteArray# s -> Int# -> Int8 -> Int8 -> IO CBool
syncCasInt8BoolArrayIO MutableByteArray# s
mba# Int#
i# Int8
old Int8
new)
  {-# INLINE casBoolMutableByteArray# #-}
  casBoolOffAddr# :: Addr# -> Int# -> Int8 -> Int8 -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# Int8
old Int8
new = IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (Addr# -> Int# -> Int8 -> Int8 -> IO CBool
syncCasInt8BoolAddrIO Addr#
addr# Int#
i# Int8
old Int8
new)
  {-# INLINE casBoolOffAddr# #-}

instance AtomicCount Int8 where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAddFetchOldInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}
  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAddFetchNewInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}
  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncSubFetchOldInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}
  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncSubFetchNewInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}
  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncAddFetchOldInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicAddFetchOldOffAddr# #-}
  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncAddFetchNewInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicAddFetchNewOffAddr# #-}
  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncSubFetchOldInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicSubFetchOldOffAddr# #-}
  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncSubFetchNewInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicSubFetchNewOffAddr# #-}

instance AtomicBits Int8 where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAndFetchOldInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}
  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAndFetchNewInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}
  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncNandFetchOldInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}
  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncNandFetchNewInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}
  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncOrFetchOldInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}
  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncOrFetchNewInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}
  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncXorFetchOldInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}
  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int8 -> IO Int8
forall s. MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncXorFetchNewInt8ArrayIO MutableByteArray# s
mba# Int#
i# Int8
a)
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}
  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncAndFetchOldInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicAndFetchOldOffAddr# #-}
  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncAndFetchNewInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicAndFetchNewOffAddr# #-}
  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncNandFetchOldInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicNandFetchOldOffAddr# #-}
  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncNandFetchNewInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicNandFetchNewOffAddr# #-}
  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncOrFetchOldInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicOrFetchOldOffAddr# #-}
  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncOrFetchNewInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicOrFetchNewOffAddr# #-}
  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncXorFetchOldInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicXorFetchOldOffAddr# #-}
  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> (# State# s, Int8 #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# Int8
a = IO Int8 -> State# s -> (# State# s, Int8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int8 -> IO Int8
syncXorFetchNewInt8AddrIO Addr#
addr# Int#
i# Int8
a)
  {-# INLINE atomicXorFetchNewOffAddr# #-}

instance Atomic Int16 where
  casMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> Int16 -> State# s -> (# State# s, Int16 #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
old Int16
new = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> Int16 -> IO Int16
syncCasInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
old Int16
new)
  {-# INLINE casMutableByteArray# #-}
  casOffAddr# :: Addr#
-> Int# -> Int16 -> Int16 -> State# s -> (# State# s, Int16 #)
casOffAddr# Addr#
addr# Int#
i# Int16
old Int16
new = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> Int16 -> IO Int16
syncCasInt16AddrIO Addr#
addr# Int#
i# Int16
old Int16
new)
  {-# INLINE casOffAddr# #-}
  casBoolMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> Int16 -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
old Int16
new =
    IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (MutableByteArray# s -> Int# -> Int16 -> Int16 -> IO CBool
forall s. MutableByteArray# s -> Int# -> Int16 -> Int16 -> IO CBool
syncCasInt16BoolArrayIO MutableByteArray# s
mba# Int#
i# Int16
old Int16
new)
  {-# INLINE casBoolMutableByteArray# #-}
  casBoolOffAddr# :: Addr# -> Int# -> Int16 -> Int16 -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# Int16
old Int16
new = IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (Addr# -> Int# -> Int16 -> Int16 -> IO CBool
syncCasInt16BoolAddrIO Addr#
addr# Int#
i# Int16
old Int16
new)
  {-# INLINE casBoolOffAddr# #-}

instance AtomicCount Int16 where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAddFetchOldInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}
  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAddFetchNewInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}
  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncSubFetchOldInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}
  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncSubFetchNewInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}
  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncAddFetchOldInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicAddFetchOldOffAddr# #-}
  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncAddFetchNewInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicAddFetchNewOffAddr# #-}
  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncSubFetchOldInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicSubFetchOldOffAddr# #-}
  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncSubFetchNewInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicSubFetchNewOffAddr# #-}

instance AtomicBits Int16 where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAndFetchOldInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}
  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAndFetchNewInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}
  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncNandFetchOldInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}
  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncNandFetchNewInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}
  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncOrFetchOldInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}
  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncOrFetchNewInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}
  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncXorFetchOldInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}
  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int16 -> IO Int16
forall s. MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncXorFetchNewInt16ArrayIO MutableByteArray# s
mba# Int#
i# Int16
a)
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}
  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncAndFetchOldInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicAndFetchOldOffAddr# #-}
  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncAndFetchNewInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicAndFetchNewOffAddr# #-}
  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncNandFetchOldInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicNandFetchOldOffAddr# #-}
  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncNandFetchNewInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicNandFetchNewOffAddr# #-}
  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncOrFetchOldInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicOrFetchOldOffAddr# #-}
  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncOrFetchNewInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicOrFetchNewOffAddr# #-}
  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncXorFetchOldInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicXorFetchOldOffAddr# #-}
  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> (# State# s, Int16 #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# Int16
a = IO Int16 -> State# s -> (# State# s, Int16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int16 -> IO Int16
syncXorFetchNewInt16AddrIO Addr#
addr# Int#
i# Int16
a)
  {-# INLINE atomicXorFetchNewOffAddr# #-}

instance Atomic Int32 where
  casMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> Int32 -> State# s -> (# State# s, Int32 #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
old Int32
new = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> Int32 -> IO Int32
syncCasInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
old Int32
new)
  {-# INLINE casMutableByteArray# #-}
  casOffAddr# :: Addr#
-> Int# -> Int32 -> Int32 -> State# s -> (# State# s, Int32 #)
casOffAddr# Addr#
addr# Int#
i# Int32
old Int32
new = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> Int32 -> IO Int32
syncCasInt32AddrIO Addr#
addr# Int#
i# Int32
old Int32
new)
  {-# INLINE casOffAddr# #-}
  casBoolMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> Int32 -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
old Int32
new =
    IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (MutableByteArray# s -> Int# -> Int32 -> Int32 -> IO CBool
forall s. MutableByteArray# s -> Int# -> Int32 -> Int32 -> IO CBool
syncCasInt32BoolArrayIO MutableByteArray# s
mba# Int#
i# Int32
old Int32
new)
  {-# INLINE casBoolMutableByteArray# #-}
  casBoolOffAddr# :: Addr# -> Int# -> Int32 -> Int32 -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# Int32
old Int32
new =
    IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (Addr# -> Int# -> Int32 -> Int32 -> IO CBool
syncCasInt32BoolAddrIO Addr#
addr# Int#
i# Int32
old Int32
new)
  {-# INLINE casBoolOffAddr# #-}

instance AtomicCount Int32 where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAddFetchOldInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}
  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAddFetchNewInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}
  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncSubFetchOldInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}
  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncSubFetchNewInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}
  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncAddFetchOldInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicAddFetchOldOffAddr# #-}
  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncAddFetchNewInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicAddFetchNewOffAddr# #-}
  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncSubFetchOldInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicSubFetchOldOffAddr# #-}
  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncSubFetchNewInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicSubFetchNewOffAddr# #-}

instance AtomicBits Int32 where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAndFetchOldInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}
  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAndFetchNewInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}
  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncNandFetchOldInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}
  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncNandFetchNewInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}
  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncOrFetchOldInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}
  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncOrFetchNewInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}
  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncXorFetchOldInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}
  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int32 -> IO Int32
forall s. MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncXorFetchNewInt32ArrayIO MutableByteArray# s
mba# Int#
i# Int32
a)
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}
  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncAndFetchOldInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicAndFetchOldOffAddr# #-}
  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncAndFetchNewInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicAndFetchNewOffAddr# #-}
  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncNandFetchOldInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicNandFetchOldOffAddr# #-}
  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncNandFetchNewInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicNandFetchNewOffAddr# #-}
  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncOrFetchOldInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicOrFetchOldOffAddr# #-}
  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncOrFetchNewInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicOrFetchNewOffAddr# #-}
  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncXorFetchOldInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicXorFetchOldOffAddr# #-}
  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> (# State# s, Int32 #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# Int32
a = IO Int32 -> State# s -> (# State# s, Int32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int32 -> IO Int32
syncXorFetchNewInt32AddrIO Addr#
addr# Int#
i# Int32
a)
  {-# INLINE atomicXorFetchNewOffAddr# #-}

-- TODO: compare with and possibly swap for primops
instance Atomic Int where
  casMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> Int -> State# s -> (# State# s, Int #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
old Int
new = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> Int -> IO Int
syncCasIntArrayIO MutableByteArray# s
mba# Int#
i# Int
old Int
new)
  {-# INLINE casMutableByteArray# #-}
  casOffAddr# :: Addr# -> Int# -> Int -> Int -> State# s -> (# State# s, Int #)
casOffAddr# Addr#
addr# Int#
i# Int
old Int
new = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> Int -> IO Int
syncCasIntAddrIO Addr#
addr# Int#
i# Int
old Int
new)
  {-# INLINE casOffAddr# #-}
  casBoolMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> Int -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
old Int
new = IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (MutableByteArray# s -> Int# -> Int -> Int -> IO CBool
forall s. MutableByteArray# s -> Int# -> Int -> Int -> IO CBool
syncCasIntBoolArrayIO MutableByteArray# s
mba# Int#
i# Int
old Int
new)
  {-# INLINE casBoolMutableByteArray# #-}
  casBoolOffAddr# :: Addr# -> Int# -> Int -> Int -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# Int
old Int
new = IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (Addr# -> Int# -> Int -> Int -> IO CBool
syncCasIntBoolAddrIO Addr#
addr# Int#
i# Int
old Int
new)
  {-# INLINE casBoolOffAddr# #-}

instance AtomicCount Int where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a =
    IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncAddFetchOldIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
    -- case fetchAddIntArray# mba# i# a# s of
    --   (# s', a'# #) -> (# s', I# a'# #)
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}
  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncAddFetchNewIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}
  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncSubFetchOldIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}
  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncSubFetchNewIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}
  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncAddFetchOldIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicAddFetchOldOffAddr# #-}
  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncAddFetchNewIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicAddFetchNewOffAddr# #-}
  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncSubFetchOldIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicSubFetchOldOffAddr# #-}
  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncSubFetchNewIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicSubFetchNewOffAddr# #-}

instance AtomicBits Int where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncAndFetchOldIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}
  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncAndFetchNewIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}
  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncNandFetchOldIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}
  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncNandFetchNewIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}
  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncOrFetchOldIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}
  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncOrFetchNewIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}
  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncXorFetchOldIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}
  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int -> State# s -> (# State# s, Int #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int -> IO Int
forall s. MutableByteArray# s -> Int# -> Int -> IO Int
syncXorFetchNewIntArrayIO MutableByteArray# s
mba# Int#
i# Int
a)
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}
  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncAndFetchOldIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicAndFetchOldOffAddr# #-}
  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncAndFetchNewIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicAndFetchNewOffAddr# #-}
  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncNandFetchOldIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicNandFetchOldOffAddr# #-}
  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncNandFetchNewIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicNandFetchNewOffAddr# #-}
  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncOrFetchOldIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicOrFetchOldOffAddr# #-}
  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncOrFetchNewIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicOrFetchNewOffAddr# #-}
  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncXorFetchOldIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicXorFetchOldOffAddr# #-}
  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> Int -> State# s -> (# State# s, Int #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# Int
a = IO Int -> State# s -> (# State# s, Int #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int -> IO Int
syncXorFetchNewIntAddrIO Addr#
addr# Int#
i# Int
a)
  {-# INLINE atomicXorFetchNewOffAddr# #-}




instance Atomic Word8 where
  casMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> Word8 -> State# s -> (# State# s, Word8 #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
old Word8
new = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> Word8 -> IO Word8
syncCasWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
old Word8
new)
  {-# INLINE casMutableByteArray# #-}
  casOffAddr# :: Addr#
-> Int# -> Word8 -> Word8 -> State# s -> (# State# s, Word8 #)
casOffAddr# Addr#
addr# Int#
i# Word8
old Word8
new = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> Word8 -> IO Word8
syncCasWord8AddrIO Addr#
addr# Int#
i# Word8
old Word8
new)
  {-# INLINE casOffAddr# #-}
  casBoolMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> Word8 -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
old Word8
new =
    IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (MutableByteArray# s -> Int# -> Word8 -> Word8 -> IO CBool
forall s. MutableByteArray# s -> Int# -> Word8 -> Word8 -> IO CBool
syncCasWord8BoolArrayIO MutableByteArray# s
mba# Int#
i# Word8
old Word8
new)
  {-# INLINE casBoolMutableByteArray# #-}
  casBoolOffAddr# :: Addr# -> Int# -> Word8 -> Word8 -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# Word8
old Word8
new = IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (Addr# -> Int# -> Word8 -> Word8 -> IO CBool
syncCasWord8BoolAddrIO Addr#
addr# Int#
i# Word8
old Word8
new)
  {-# INLINE casBoolOffAddr# #-}

instance AtomicCount Word8 where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAddFetchOldWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}
  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAddFetchNewWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}
  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncSubFetchOldWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}
  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncSubFetchNewWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}
  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncAddFetchOldWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicAddFetchOldOffAddr# #-}
  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncAddFetchNewWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicAddFetchNewOffAddr# #-}
  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncSubFetchOldWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicSubFetchOldOffAddr# #-}
  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncSubFetchNewWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicSubFetchNewOffAddr# #-}

instance AtomicBits Word8 where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAndFetchOldWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}
  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAndFetchNewWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}
  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncNandFetchOldWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}
  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncNandFetchNewWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}
  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncOrFetchOldWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}
  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncOrFetchNewWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}
  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncXorFetchOldWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}
  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word8 -> IO Word8
forall s. MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncXorFetchNewWord8ArrayIO MutableByteArray# s
mba# Int#
i# Word8
a)
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}
  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncAndFetchOldWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicAndFetchOldOffAddr# #-}
  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncAndFetchNewWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicAndFetchNewOffAddr# #-}
  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncNandFetchOldWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicNandFetchOldOffAddr# #-}
  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncNandFetchNewWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicNandFetchNewOffAddr# #-}
  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncOrFetchOldWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicOrFetchOldOffAddr# #-}
  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncOrFetchNewWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicOrFetchNewOffAddr# #-}
  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncXorFetchOldWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicXorFetchOldOffAddr# #-}
  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> (# State# s, Word8 #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# Word8
a = IO Word8 -> State# s -> (# State# s, Word8 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word8 -> IO Word8
syncXorFetchNewWord8AddrIO Addr#
addr# Int#
i# Word8
a)
  {-# INLINE atomicXorFetchNewOffAddr# #-}

instance Atomic Word16 where
  casMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> Word16 -> State# s -> (# State# s, Word16 #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
old Word16
new = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> Word16 -> IO Word16
forall s.
MutableByteArray# s -> Int# -> Word16 -> Word16 -> IO Word16
syncCasWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
old Word16
new)
  {-# INLINE casMutableByteArray# #-}
  casOffAddr# :: Addr#
-> Int# -> Word16 -> Word16 -> State# s -> (# State# s, Word16 #)
casOffAddr# Addr#
addr# Int#
i# Word16
old Word16
new = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> Word16 -> IO Word16
syncCasWord16AddrIO Addr#
addr# Int#
i# Word16
old Word16
new)
  {-# INLINE casOffAddr# #-}
  casBoolMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> Word16 -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
old Word16
new =
    IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (MutableByteArray# s -> Int# -> Word16 -> Word16 -> IO CBool
forall s.
MutableByteArray# s -> Int# -> Word16 -> Word16 -> IO CBool
syncCasWord16BoolArrayIO MutableByteArray# s
mba# Int#
i# Word16
old Word16
new)
  {-# INLINE casBoolMutableByteArray# #-}
  casBoolOffAddr# :: Addr#
-> Int# -> Word16 -> Word16 -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# Word16
old Word16
new = IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (Addr# -> Int# -> Word16 -> Word16 -> IO CBool
syncCasWord16BoolAddrIO Addr#
addr# Int#
i# Word16
old Word16
new)
  {-# INLINE casBoolOffAddr# #-}

instance AtomicCount Word16 where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAddFetchOldWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}
  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAddFetchNewWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}
  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncSubFetchOldWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}
  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncSubFetchNewWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}
  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncAddFetchOldWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicAddFetchOldOffAddr# #-}
  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncAddFetchNewWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicAddFetchNewOffAddr# #-}
  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncSubFetchOldWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicSubFetchOldOffAddr# #-}
  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncSubFetchNewWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicSubFetchNewOffAddr# #-}

instance AtomicBits Word16 where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAndFetchOldWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}
  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAndFetchNewWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}
  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncNandFetchOldWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}
  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncNandFetchNewWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}
  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncOrFetchOldWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}
  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncOrFetchNewWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}
  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncXorFetchOldWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}
  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word16 -> IO Word16
forall s. MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncXorFetchNewWord16ArrayIO MutableByteArray# s
mba# Int#
i# Word16
a)
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}
  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncAndFetchOldWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicAndFetchOldOffAddr# #-}
  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncAndFetchNewWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicAndFetchNewOffAddr# #-}
  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncNandFetchOldWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicNandFetchOldOffAddr# #-}
  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncNandFetchNewWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicNandFetchNewOffAddr# #-}
  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncOrFetchOldWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicOrFetchOldOffAddr# #-}
  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncOrFetchNewWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicOrFetchNewOffAddr# #-}
  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncXorFetchOldWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicXorFetchOldOffAddr# #-}
  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> (# State# s, Word16 #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# Word16
a = IO Word16 -> State# s -> (# State# s, Word16 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word16 -> IO Word16
syncXorFetchNewWord16AddrIO Addr#
addr# Int#
i# Word16
a)
  {-# INLINE atomicXorFetchNewOffAddr# #-}


instance Atomic Word32 where
  casMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> Word32 -> State# s -> (# State# s, Word32 #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
old Word32
new = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> Word32 -> IO Word32
forall s.
MutableByteArray# s -> Int# -> Word32 -> Word32 -> IO Word32
syncCasWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
old Word32
new)
  {-# INLINE casMutableByteArray# #-}
  casOffAddr# :: Addr#
-> Int# -> Word32 -> Word32 -> State# s -> (# State# s, Word32 #)
casOffAddr# Addr#
addr# Int#
i# Word32
old Word32
new = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> Word32 -> IO Word32
syncCasWord32AddrIO Addr#
addr# Int#
i# Word32
old Word32
new)
  {-# INLINE casOffAddr# #-}
  casBoolMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> Word32 -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
old Word32
new =
    IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (MutableByteArray# s -> Int# -> Word32 -> Word32 -> IO CBool
forall s.
MutableByteArray# s -> Int# -> Word32 -> Word32 -> IO CBool
syncCasWord32BoolArrayIO MutableByteArray# s
mba# Int#
i# Word32
old Word32
new)
  {-# INLINE casBoolMutableByteArray# #-}
  casBoolOffAddr# :: Addr#
-> Int# -> Word32 -> Word32 -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# Word32
old Word32
new = IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (Addr# -> Int# -> Word32 -> Word32 -> IO CBool
syncCasWord32BoolAddrIO Addr#
addr# Int#
i# Word32
old Word32
new)
  {-# INLINE casBoolOffAddr# #-}

instance AtomicCount Word32 where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAddFetchOldWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}
  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAddFetchNewWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}
  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncSubFetchOldWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}
  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncSubFetchNewWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}
  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncAddFetchOldWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicAddFetchOldOffAddr# #-}
  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncAddFetchNewWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicAddFetchNewOffAddr# #-}
  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncSubFetchOldWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicSubFetchOldOffAddr# #-}
  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncSubFetchNewWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicSubFetchNewOffAddr# #-}

instance AtomicBits Word32 where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAndFetchOldWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}
  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAndFetchNewWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}
  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncNandFetchOldWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}
  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncNandFetchNewWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}
  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncOrFetchOldWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}
  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncOrFetchNewWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}
  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncXorFetchOldWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}
  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word32 -> IO Word32
forall s. MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncXorFetchNewWord32ArrayIO MutableByteArray# s
mba# Int#
i# Word32
a)
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}
  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncAndFetchOldWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicAndFetchOldOffAddr# #-}
  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncAndFetchNewWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicAndFetchNewOffAddr# #-}
  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncNandFetchOldWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicNandFetchOldOffAddr# #-}
  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncNandFetchNewWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicNandFetchNewOffAddr# #-}
  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncOrFetchOldWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicOrFetchOldOffAddr# #-}
  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncOrFetchNewWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicOrFetchNewOffAddr# #-}
  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncXorFetchOldWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicXorFetchOldOffAddr# #-}
  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> (# State# s, Word32 #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# Word32
a = IO Word32 -> State# s -> (# State# s, Word32 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word32 -> IO Word32
syncXorFetchNewWord32AddrIO Addr#
addr# Int#
i# Word32
a)
  {-# INLINE atomicXorFetchNewOffAddr# #-}


instance Atomic Word where
  casMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> Word -> State# s -> (# State# s, Word #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
old Word
new = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> Word -> IO Word
syncCasWordArrayIO MutableByteArray# s
mba# Int#
i# Word
old Word
new)
  {-# INLINE casMutableByteArray# #-}
  casOffAddr# :: Addr# -> Int# -> Word -> Word -> State# s -> (# State# s, Word #)
casOffAddr# Addr#
addr# Int#
i# Word
old Word
new = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> Word -> IO Word
syncCasWordAddrIO Addr#
addr# Int#
i# Word
old Word
new)
  {-# INLINE casOffAddr# #-}
  casBoolMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> Word -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
old Word
new =
    IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (MutableByteArray# s -> Int# -> Word -> Word -> IO CBool
forall s. MutableByteArray# s -> Int# -> Word -> Word -> IO CBool
syncCasWordBoolArrayIO MutableByteArray# s
mba# Int#
i# Word
old Word
new)
  {-# INLINE casBoolMutableByteArray# #-}
  casBoolOffAddr# :: Addr# -> Int# -> Word -> Word -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# Word
old Word
new = IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (Addr# -> Int# -> Word -> Word -> IO CBool
syncCasWordBoolAddrIO Addr#
addr# Int#
i# Word
old Word
new)
  {-# INLINE casBoolOffAddr# #-}

instance AtomicCount Word where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncAddFetchOldWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}
  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncAddFetchNewWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}
  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncSubFetchOldWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}
  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncSubFetchNewWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}
  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncAddFetchOldWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicAddFetchOldOffAddr# #-}
  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncAddFetchNewWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicAddFetchNewOffAddr# #-}
  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncSubFetchOldWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicSubFetchOldOffAddr# #-}
  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncSubFetchNewWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicSubFetchNewOffAddr# #-}

instance AtomicBits Word where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a =
    IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncAndFetchOldWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}
  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a =
    IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncAndFetchNewWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}
  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a =
    IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncNandFetchOldWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}
  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a =
    IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncNandFetchNewWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}
  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a =
    IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncOrFetchOldWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}
  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a =
    IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncOrFetchNewWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}
  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a =
    IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncXorFetchOldWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}
  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word -> State# s -> (# State# s, Word #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word
a =
    IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word -> IO Word
forall s. MutableByteArray# s -> Int# -> Word -> IO Word
syncXorFetchNewWordArrayIO MutableByteArray# s
mba# Int#
i# Word
a)
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}
  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncAndFetchOldWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicAndFetchOldOffAddr# #-}
  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncAndFetchNewWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicAndFetchNewOffAddr# #-}
  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncNandFetchOldWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicNandFetchOldOffAddr# #-}
  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncNandFetchNewWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicNandFetchNewOffAddr# #-}
  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncOrFetchOldWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicOrFetchOldOffAddr# #-}
  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncOrFetchNewWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicOrFetchNewOffAddr# #-}
  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncXorFetchOldWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicXorFetchOldOffAddr# #-}
  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> Word -> State# s -> (# State# s, Word #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# Word
a = IO Word -> State# s -> (# State# s, Word #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word -> IO Word
syncXorFetchNewWordAddrIO Addr#
addr# Int#
i# Word
a)
  {-# INLINE atomicXorFetchNewOffAddr# #-}

#if WORD_SIZE_IN_BITS == 64

-- | Available only on 64bit architectures
instance Atomic Int64 where
  casMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> Int64 -> State# s -> (# State# s, Int64 #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
old Int64
new = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> Int64 -> IO Int64
syncCasInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
old Int64
new)
  {-# INLINE casMutableByteArray# #-}
  casOffAddr# :: Addr#
-> Int# -> Int64 -> Int64 -> State# s -> (# State# s, Int64 #)
casOffAddr# Addr#
addr# Int#
i# Int64
old Int64
new = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> Int64 -> IO Int64
syncCasInt64AddrIO Addr#
addr# Int#
i# Int64
old Int64
new)
  {-# INLINE casOffAddr# #-}
  casBoolMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> Int64 -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
old Int64
new =
    IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (MutableByteArray# s -> Int# -> Int64 -> Int64 -> IO CBool
forall s. MutableByteArray# s -> Int# -> Int64 -> Int64 -> IO CBool
syncCasInt64BoolArrayIO MutableByteArray# s
mba# Int#
i# Int64
old Int64
new)
  {-# INLINE casBoolMutableByteArray# #-}
  casBoolOffAddr# :: Addr# -> Int# -> Int64 -> Int64 -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# Int64
old Int64
new = IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (Addr# -> Int# -> Int64 -> Int64 -> IO CBool
syncCasInt64BoolAddrIO Addr#
addr# Int#
i# Int64
old Int64
new)
  {-# INLINE casBoolOffAddr# #-}

-- | Available only on 64bit architectures
instance AtomicCount Int64 where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAddFetchOldInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}
  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAddFetchNewInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}
  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncSubFetchOldInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}
  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncSubFetchNewInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}
  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncAddFetchOldInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicAddFetchOldOffAddr# #-}
  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncAddFetchNewInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicAddFetchNewOffAddr# #-}
  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncSubFetchOldInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicSubFetchOldOffAddr# #-}
  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncSubFetchNewInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicSubFetchNewOffAddr# #-}

-- | Available only on 64bit architectures
instance AtomicBits Int64 where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a =
    IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAndFetchOldInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}
  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a =
    IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAndFetchNewInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}
  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a =
    IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncNandFetchOldInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}
  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a =
    IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncNandFetchNewInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}
  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a =
    IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncOrFetchOldInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}
  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a =
    IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncOrFetchNewInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}
  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a =
    IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncXorFetchOldInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}
  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Int64
a =
    IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Int64 -> IO Int64
forall s. MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncXorFetchNewInt64ArrayIO MutableByteArray# s
mba# Int#
i# Int64
a)
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}
  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncAndFetchOldInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicAndFetchOldOffAddr# #-}
  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncAndFetchNewInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicAndFetchNewOffAddr# #-}
  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncNandFetchOldInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicNandFetchOldOffAddr# #-}
  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncNandFetchNewInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicNandFetchNewOffAddr# #-}
  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncOrFetchOldInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicOrFetchOldOffAddr# #-}
  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncOrFetchNewInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicOrFetchNewOffAddr# #-}
  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncXorFetchOldInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicXorFetchOldOffAddr# #-}
  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> (# State# s, Int64 #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# Int64
a = IO Int64 -> State# s -> (# State# s, Int64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Int64 -> IO Int64
syncXorFetchNewInt64AddrIO Addr#
addr# Int#
i# Int64
a)
  {-# INLINE atomicXorFetchNewOffAddr# #-}

-- | Available only on 64bit architectures
instance Atomic Word64 where
  casMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> Word64 -> State# s -> (# State# s, Word64 #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
old Word64
new = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> Word64 -> IO Word64
forall s.
MutableByteArray# s -> Int# -> Word64 -> Word64 -> IO Word64
syncCasWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
old Word64
new)
  {-# INLINE casMutableByteArray# #-}
  casOffAddr# :: Addr#
-> Int# -> Word64 -> Word64 -> State# s -> (# State# s, Word64 #)
casOffAddr# Addr#
addr# Int#
i# Word64
old Word64
new = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> Word64 -> IO Word64
syncCasWord64AddrIO Addr#
addr# Int#
i# Word64
old Word64
new)
  {-# INLINE casOffAddr# #-}
  casBoolMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> Word64 -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
old Word64
new =
    IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (MutableByteArray# s -> Int# -> Word64 -> Word64 -> IO CBool
forall s.
MutableByteArray# s -> Int# -> Word64 -> Word64 -> IO CBool
syncCasWord64BoolArrayIO MutableByteArray# s
mba# Int#
i# Word64
old Word64
new)
  {-# INLINE casBoolMutableByteArray# #-}
  casBoolOffAddr# :: Addr#
-> Int# -> Word64 -> Word64 -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# Word64
old Word64
new = IO CBool -> State# s -> (# State# s, Bool #)
forall s. IO CBool -> State# s -> (# State# s, Bool #)
ioCBoolToBoolBase (Addr# -> Int# -> Word64 -> Word64 -> IO CBool
syncCasWord64BoolAddrIO Addr#
addr# Int#
i# Word64
old Word64
new)
  {-# INLINE casBoolOffAddr# #-}

-- | Available only on 64bit architectures
instance AtomicCount Word64 where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicAddFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAddFetchOldWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}
  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicAddFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAddFetchNewWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}
  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicSubFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncSubFetchOldWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}
  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicSubFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncSubFetchNewWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}
  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicAddFetchOldOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncAddFetchOldWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicAddFetchOldOffAddr# #-}
  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicAddFetchNewOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncAddFetchNewWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicAddFetchNewOffAddr# #-}
  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicSubFetchOldOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncSubFetchOldWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicSubFetchOldOffAddr# #-}
  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicSubFetchNewOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncSubFetchNewWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicSubFetchNewOffAddr# #-}

-- | Available only on 64bit architectures
instance AtomicBits Word64 where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicAndFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAndFetchOldWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}
  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicAndFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAndFetchNewWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}
  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicNandFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncNandFetchOldWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}
  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicNandFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncNandFetchNewWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}
  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicOrFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncOrFetchOldWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}
  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicOrFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncOrFetchNewWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}
  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicXorFetchOldMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncXorFetchOldWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}
  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicXorFetchNewMutableByteArray# MutableByteArray# s
mba# Int#
i# Word64
a =
    IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (MutableByteArray# s -> Int# -> Word64 -> IO Word64
forall s. MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncXorFetchNewWord64ArrayIO MutableByteArray# s
mba# Int#
i# Word64
a)
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}
  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicAndFetchOldOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncAndFetchOldWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicAndFetchOldOffAddr# #-}
  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicAndFetchNewOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncAndFetchNewWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicAndFetchNewOffAddr# #-}
  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicNandFetchOldOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncNandFetchOldWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicNandFetchOldOffAddr# #-}
  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicNandFetchNewOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncNandFetchNewWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicNandFetchNewOffAddr# #-}
  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicOrFetchOldOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncOrFetchOldWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicOrFetchOldOffAddr# #-}
  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicOrFetchNewOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncOrFetchNewWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicOrFetchNewOffAddr# #-}
  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicXorFetchOldOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncXorFetchOldWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicXorFetchOldOffAddr# #-}
  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> (# State# s, Word64 #)
atomicXorFetchNewOffAddr# Addr#
addr# Int#
i# Word64
a = IO Word64 -> State# s -> (# State# s, Word64 #)
forall s' (m :: * -> *) a s.
MonadPrimBase s' m =>
m a -> State# s -> (# State# s, a #)
unsafePrimBase (Addr# -> Int# -> Word64 -> IO Word64
syncXorFetchNewWord64AddrIO Addr#
addr# Int#
i# Word64
a)
  {-# INLINE atomicXorFetchNewOffAddr# #-}

-- | Available only on 64bit architectures
instance Atomic CLLong
-- | Available only on 64bit architectures
instance AtomicCount CLLong
-- | Available only on 64bit architectures
instance AtomicBits CLLong

-- | Available only on 64bit architectures
instance Atomic CULLong
-- | Available only on 64bit architectures
instance AtomicCount CULLong
-- | Available only on 64bit architectures
instance AtomicBits CULLong

#endif

instance Atomic Bool
instance AtomicBits Bool

instance Atomic Char

instance Atomic (Ptr a)

instance Atomic (FunPtr a)

instance Atomic IntPtr
instance AtomicCount IntPtr
instance AtomicBits IntPtr

instance Atomic WordPtr
instance AtomicCount WordPtr
instance AtomicBits WordPtr


instance Atomic CBool
instance AtomicCount CBool
instance AtomicBits CBool

instance Atomic CChar
instance AtomicCount CChar
instance AtomicBits CChar

instance Atomic CSChar
instance AtomicCount CSChar
instance AtomicBits CSChar

instance Atomic CUChar
instance AtomicCount CUChar
instance AtomicBits CUChar

instance Atomic CShort
instance AtomicCount CShort
instance AtomicBits CShort

instance Atomic CUShort
instance AtomicCount CUShort
instance AtomicBits CUShort

instance Atomic CInt
instance AtomicCount CInt
instance AtomicBits CInt

instance Atomic CUInt
instance AtomicCount CUInt
instance AtomicBits CUInt

instance Atomic CLong
instance AtomicCount CLong
instance AtomicBits CLong

instance Atomic CULong
instance AtomicCount CULong
instance AtomicBits CULong

instance Atomic CPtrdiff
instance AtomicCount CPtrdiff
instance AtomicBits CPtrdiff

instance Atomic CSize
instance AtomicCount CSize
instance AtomicBits CSize

instance Atomic CWchar
instance AtomicCount CWchar
instance AtomicBits CWchar

instance Atomic CSigAtomic
instance AtomicCount CSigAtomic
instance AtomicBits CSigAtomic

instance Atomic CIntPtr
instance AtomicCount CIntPtr
instance AtomicBits CIntPtr

instance Atomic CUIntPtr
instance AtomicCount CUIntPtr
instance AtomicBits CUIntPtr

instance Atomic CIntMax
instance AtomicCount CIntMax
instance AtomicBits CIntMax

instance Atomic CUIntMax
instance AtomicCount CUIntMax
instance AtomicBits CUIntMax

instance Atomic Fd
instance AtomicCount Fd
instance AtomicBits Fd

instance Atomic Errno
instance AtomicCount Errno



#if defined(HTYPE_DEV_T)
instance Atomic CDev
instance AtomicCount CDev
instance AtomicBits CDev
#endif
#if defined(HTYPE_INO_T)
instance Atomic CIno
instance AtomicCount CIno
instance AtomicBits CIno
#endif
#if defined(HTYPE_MODE_T)
instance Atomic CMode
instance AtomicCount CMode
instance AtomicBits CMode
#endif
#if defined(HTYPE_OFF_T)
instance Atomic COff
instance AtomicCount COff
instance AtomicBits COff
#endif
#if defined(HTYPE_PID_T)
instance Atomic CPid
instance AtomicCount CPid
instance AtomicBits CPid
#endif
#if defined(HTYPE_SSIZE_T)
instance Atomic CSsize
instance AtomicCount CSsize
instance AtomicBits CSsize
#endif
#if defined(HTYPE_GID_T)
instance Atomic CGid
instance AtomicCount CGid
instance AtomicBits CGid
#endif
#if defined(HTYPE_NLINK_T)
instance Atomic CNlink
instance AtomicCount CNlink
instance AtomicBits CNlink
#endif
#if defined(HTYPE_UID_T)
instance Atomic CUid
instance AtomicCount CUid
instance AtomicBits CUid
#endif
#if defined(HTYPE_CC_T)
instance Atomic CCc
instance AtomicCount CCc
instance AtomicBits CCc
#endif
#if defined(HTYPE_SPEED_T)
instance Atomic CSpeed
instance AtomicCount CSpeed
instance AtomicBits CSpeed
#endif
#if defined(HTYPE_TCFLAG_T)
instance Atomic CTcflag
instance AtomicCount CTcflag
instance AtomicBits CTcflag
#endif
#if defined(HTYPE_RLIM_T)
instance Atomic CRLim
instance AtomicCount CRLim
instance AtomicBits CRLim
#endif

#if __GLASGOW_HASKELL__ >= 802

#if defined(HTYPE_BLKSIZE_T)
instance Atomic CBlkSize
instance AtomicCount CBlkSize
instance AtomicBits CBlkSize
#endif
#if defined(HTYPE_BLKCNT_T)
instance Atomic CBlkCnt
instance AtomicCount CBlkCnt
instance AtomicBits CBlkCnt
#endif
#if defined(HTYPE_CLOCKID_T)
instance Atomic CClockId
instance AtomicCount CClockId
instance AtomicBits CClockId
#endif
#if defined(HTYPE_FSBLKCNT_T)
instance Atomic CFsBlkCnt
instance AtomicCount CFsBlkCnt
instance AtomicBits CFsBlkCnt
#endif
#if defined(HTYPE_FSFILCNT_T)
instance Atomic CFsFilCnt
instance AtomicCount CFsFilCnt
instance AtomicBits CFsFilCnt
#endif
#if defined(HTYPE_ID_T)
instance Atomic CId
instance AtomicCount CId
instance AtomicBits CId
#endif
#if defined(HTYPE_KEY_T)
instance Atomic CKey
instance AtomicCount CKey
instance AtomicBits CKey
#endif
#if defined(HTYPE_TIMER_T)
instance Atomic CTimer
instance AtomicCount CTimer
instance AtomicBits CTimer
#endif

#if __GLASGOW_HASKELL__ >= 810

#if defined(HTYPE_SOCKLEN_T)
instance Atomic CSocklen
instance AtomicCount CSocklen
instance AtomicBits CSocklen
#endif
#if defined(HTYPE_NFDS_T)
instance Atomic CNfds
instance AtomicCount CNfds
instance AtomicBIts CNfds
#endif

#endif /* __GLASGOW_HASKELL__ >= 810 */

#endif /* __GLASGOW_HASKELL__ >= 802 */

#if __GLASGOW_HASKELL__ >= 800
instance Atomic a => Atomic (Max a)
instance Atomic a => Atomic (Min a)
instance Atomic a => Atomic (Data.Semigroup.First a)
instance Atomic a => Atomic (Data.Semigroup.Last a)

instance Atomic a => Atomic (Const a b)
instance AtomicCount a => AtomicCount (Const a b)
instance AtomicBits a => AtomicBits (Const a b)

#else

deriving instance Bits a => Bits (Identity a)
#endif /* __GLASGOW_HASKELL__ >= 800 */

instance Atomic a => Atomic (Identity a)
instance AtomicCount a => AtomicCount (Identity a)
instance AtomicBits a => AtomicBits (Identity a)

instance Atomic Ordering

instance Atomic IODeviceType

instance Atomic SeekMode

instance Atomic BlockReason

instance Atomic ThreadStatus

instance Atomic IOMode

instance Atomic Newline

instance Atomic NewlineMode

instance Atomic GeneralCategory

instance Atomic a => Atomic (Down a)
instance AtomicCount a => AtomicCount (Down a)
--instance AtomicBits a => AtomicBits (Down a)

instance Atomic a => Atomic (Dual a)
instance AtomicCount a => AtomicCount (Dual a)
--instance AtomicBits a => AtomicBits (Dual a)

instance Atomic a => Atomic (Sum a)
instance AtomicCount a => AtomicCount (Sum a)
--instance AtomicBits a => AtomicBits (Sum a)

instance Atomic a => Atomic (Product a)
instance AtomicCount a => AtomicCount (Product a)
--instance AtomicBits a => AtomicBits (Product a)

instance Atomic All
--instance AtomicBits All

instance Atomic Any
--instance AtomicBits Any