GHC.ForeignPtr

base-4.13.0.0: Basic libraries

Copyright | (c) The University of Glasgow 1992-2003
License | see libraries/base/LICENSE
Maintainer | cvs-ghc@haskell.org
Stability | internal
Portability | non-portable (GHC extensions)
Safe Haskell | Unsafe
Language | Haskell2010

GHC.ForeignPtr

Description

GHC's implementation of the `ForeignPtr` data type.

Synopsis

- data ForeignPtr a = ForeignPtr Addr# ForeignPtrContents
- data ForeignPtrContents
  - = PlainForeignPtr !(IORef Finalizers)
  - | MallocPtr (MutableByteArray# RealWorld) !(IORef Finalizers)
  - | PlainPtr (MutableByteArray# RealWorld)
- type FinalizerPtr a = FunPtr (Ptr a -> IO ())
- type FinalizerEnvPtr env a = FunPtr (Ptr env -> Ptr a -> IO ())
- newForeignPtr_ :: Ptr a -> IO (ForeignPtr a)
- mallocForeignPtr :: Storable a => IO (ForeignPtr a)
- mallocPlainForeignPtr :: Storable a => IO (ForeignPtr a)
- mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)
- mallocPlainForeignPtrBytes :: Int -> IO (ForeignPtr a)
- mallocForeignPtrAlignedBytes :: Int -> Int -> IO (ForeignPtr a)
- mallocPlainForeignPtrAlignedBytes :: Int -> Int -> IO (ForeignPtr a)
- addForeignPtrFinalizer :: FinalizerPtr a -> ForeignPtr a -> IO ()
- addForeignPtrFinalizerEnv :: FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()
- touchForeignPtr :: ForeignPtr a -> IO ()
- unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a
- castForeignPtr :: ForeignPtr a -> ForeignPtr b
- plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b
- newConcForeignPtr :: Ptr a -> IO () -> IO (ForeignPtr a)
- addForeignPtrConcFinalizer :: ForeignPtr a -> IO () -> IO ()
- finalizeForeignPtr :: ForeignPtr a -> IO ()

# Documentation

data ForeignPtr a Source #

The type `ForeignPtr` represents references to objects that are maintained in a foreign language, i.e., that are not part of the data structures usually managed by the Haskell storage manager. The essential difference between `ForeignPtr`s and vanilla memory references of type `Ptr a` is that the former may be associated with finalizers. A finalizer is a routine that is invoked when the Haskell storage manager detects that - within the Haskell heap and stack - there are no more references left that are pointing to the `ForeignPtr`. Typically, the finalizer will, then, invoke routines in the foreign language that free the resources bound by the foreign object.

The `ForeignPtr` is parameterised in the same way as `Ptr`. The type argument of `ForeignPtr` should normally be an instance of class `Storable`.

Constructors

ForeignPtr Addr# ForeignPtrContents |

#### Instances

Instances details

Eq (ForeignPtr a) # | Since: base-2.1
Instance details Defined in GHC.ForeignPtr Methods (==) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (/=) :: ForeignPtr a -> ForeignPtr a -> Bool Source #
Data a => Data (ForeignPtr a) # | Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignPtr a -> c (ForeignPtr a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignPtr a) Source # toConstr :: ForeignPtr a -> Constr Source # dataTypeOf :: ForeignPtr a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignPtr a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ForeignPtr a)) Source # gmapT :: (forall b. Data b => b -> b) -> ForeignPtr a -> ForeignPtr a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ForeignPtr a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignPtr a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) Source #
Ord (ForeignPtr a) # | Since: base-2.1
Instance details Defined in GHC.ForeignPtr Methods compare :: ForeignPtr a -> ForeignPtr a -> Ordering Source # (<) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (<=) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (>) :: ForeignPtr a -> ForeignPtr a -> Bool Source # (>=) :: ForeignPtr a -> ForeignPtr a -> Bool Source # max :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a Source # min :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a Source #
Show (ForeignPtr a) # | Since: base-2.1
Instance details Defined in GHC.ForeignPtr Methods showsPrec :: Int -> ForeignPtr a -> ShowS Source # show :: ForeignPtr a -> String Source # showList :: [ForeignPtr a] -> ShowS Source #

data ForeignPtrContents Source #

Constructors

PlainForeignPtr !(IORef Finalizers) |
MallocPtr (MutableByteArray# RealWorld) !(IORef Finalizers) |
PlainPtr (MutableByteArray# RealWorld) |

type FinalizerPtr a = FunPtr (Ptr a -> IO ()) Source #

A finalizer is represented as a pointer to a foreign function that, at finalisation time, gets as an argument a plain pointer variant of the foreign pointer that the finalizer is associated with.

Note that the foreign function must use the `ccall` calling convention.

type FinalizerEnvPtr env a = FunPtr (Ptr env -> Ptr a -> IO ()) Source #

newForeignPtr_ :: Ptr a -> IO (ForeignPtr a) Source #

Turns a plain memory reference into a foreign pointer that may be associated with finalizers by using `addForeignPtrFinalizer`.

mallocForeignPtr :: Storable a => IO (ForeignPtr a) Source #

Allocate some memory and return a `ForeignPtr` to it. The memory will be released automatically when the `ForeignPtr` is discarded.

`mallocForeignPtr` is equivalent to

       do { p <- malloc; newForeignPtr finalizerFree p }

although it may be implemented differently internally: you may not assume that the memory returned by `mallocForeignPtr` has been allocated with `malloc`.

GHC notes: `mallocForeignPtr` has a heavily optimised implementation in GHC. It uses pinned memory in the garbage collected heap, so the `ForeignPtr` does not require a finalizer to free the memory. Use of `mallocForeignPtr` and associated functions is strongly recommended in preference to `newForeignPtr` with a finalizer.

mallocPlainForeignPtr :: Storable a => IO (ForeignPtr a) Source #

Allocate some memory and return a `ForeignPtr` to it. The memory will be released automatically when the `ForeignPtr` is discarded.

GHC notes: `mallocPlainForeignPtr` has a heavily optimised implementation in GHC. It uses pinned memory in the garbage collected heap, as for mallocForeignPtr. Unlike mallocForeignPtr, a ForeignPtr created with mallocPlainForeignPtr carries no finalizers. It is not possible to add a finalizer to a ForeignPtr created with mallocPlainForeignPtr. This is useful for ForeignPtrs that will live only inside Haskell (such as those created for packed strings). Attempts to add a finalizer to a ForeignPtr created this way, or to finalize such a pointer, will throw an exception.

mallocForeignPtrBytes :: Int -> IO (ForeignPtr a) Source #

This function is similar to `mallocForeignPtr`, except that the size of the memory required is given explicitly as a number of bytes.

mallocPlainForeignPtrBytes :: Int -> IO (ForeignPtr a) Source #

This function is similar to `mallocForeignPtrBytes`, except that the internally an optimised ForeignPtr representation with no finalizer is used. Attempts to add a finalizer will cause an exception to be thrown.

mallocForeignPtrAlignedBytes :: Int -> Int -> IO (ForeignPtr a) Source #

This function is similar to `mallocForeignPtrBytes`, except that the size and alignment of the memory required is given explicitly as numbers of bytes.

mallocPlainForeignPtrAlignedBytes :: Int -> Int -> IO (ForeignPtr a) Source #

This function is similar to `mallocForeignPtrAlignedBytes`, except that the internally an optimised ForeignPtr representation with no finalizer is used. Attempts to add a finalizer will cause an exception to be thrown.

addForeignPtrFinalizer :: FinalizerPtr a -> ForeignPtr a -> IO () Source #

This function adds a finalizer to the given foreign object. The finalizer will run before all other finalizers for the same object which have already been registered.

addForeignPtrFinalizerEnv :: FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO () Source #

Like `addForeignPtrFinalizerEnv` but allows the finalizer to be passed an additional environment parameter to be passed to the finalizer. The environment passed to the finalizer is fixed by the second argument to `addForeignPtrFinalizerEnv`

touchForeignPtr :: ForeignPtr a -> IO () Source #

This function ensures that the foreign object in question is alive at the given place in the sequence of IO actions. In particular `withForeignPtr` does a `touchForeignPtr` after it executes the user action.

Note that this function should not be used to express dependencies between finalizers on `ForeignPtr`s. For example, if the finalizer for a `ForeignPtr` `F1` calls `touchForeignPtr` on a second `ForeignPtr` `F2`, then the only guarantee is that the finalizer for `F2` is never started before the finalizer for `F1`. They might be started together if for example both `F1` and `F2` are otherwise unreachable, and in that case the scheduler might end up running the finalizer for `F2` first.

In general, it is not recommended to use finalizers on separate objects with ordering constraints between them. To express the ordering robustly requires explicit synchronisation using `MVar`s between the finalizers, but even then the runtime sometimes runs multiple finalizers sequentially in a single thread (for performance reasons), so synchronisation between finalizers could result in artificial deadlock. Another alternative is to use explicit reference counting.

unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a Source #

This function extracts the pointer component of a foreign pointer. This is a potentially dangerous operations, as if the argument to `unsafeForeignPtrToPtr` is the last usage occurrence of the given foreign pointer, then its finalizer(s) will be run, which potentially invalidates the plain pointer just obtained. Hence, `touchForeignPtr` must be used wherever it has to be guaranteed that the pointer lives on - i.e., has another usage occurrence.

To avoid subtle coding errors, hand written marshalling code should preferably use `withForeignPtr` rather than combinations of `unsafeForeignPtrToPtr` and `touchForeignPtr`. However, the latter routines are occasionally preferred in tool generated marshalling code.

castForeignPtr :: ForeignPtr a -> ForeignPtr b Source #

This function casts a `ForeignPtr` parameterised by one type into another type.

plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b Source #

Advances the given address by the given offset in bytes.

The new `ForeignPtr` shares the finalizer of the original, equivalent from a finalization standpoint to just creating another reference to the original. That is, the finalizer will not be called before the new `ForeignPtr` is unreachable, nor will it be called an additional time due to this call, and the finalizer will be called with the same address that it would have had this call not happened, *not* the new address.

Since: base-4.10.0.0

newConcForeignPtr :: Ptr a -> IO () -> IO (ForeignPtr a) Source #

Turns a plain memory reference into a foreign object by associating a finalizer - given by the monadic operation - with the reference. The storage manager will start the finalizer, in a separate thread, some time after the last reference to the `ForeignPtr` is dropped. There is no guarantee of promptness, and in fact there is no guarantee that the finalizer will eventually run at all.

Note that references from a finalizer do not necessarily prevent another object from being finalized. If A's finalizer refers to B (perhaps using `touchForeignPtr`, then the only guarantee is that B's finalizer will never be started before A's. If both A and B are unreachable, then both finalizers will start together. See `touchForeignPtr` for more on finalizer ordering.

addForeignPtrConcFinalizer :: ForeignPtr a -> IO () -> IO () Source #

This function adds a finalizer to the given `ForeignPtr`. The finalizer will run before all other finalizers for the same object which have already been registered.

This is a variant of `addForeignPtrFinalizer`, where the finalizer is an arbitrary `IO` action. When it is invoked, the finalizer will run in a new thread.

NB. Be very careful with these finalizers. One common trap is that if a finalizer references another finalized value, it does not prevent that value from being finalized. In particular, `Handle`s are finalized objects, so a finalizer should not refer to a `Handle` (including `stdout`, `stdin`, or `stderr`).

finalizeForeignPtr :: ForeignPtr a -> IO () Source #

Causes the finalizers associated with a foreign pointer to be run immediately.