LLVM.Extra.Memory

Documentation

class (Phi llvmValue, Undefined llvmValue, IsType llvmStruct) => C llvmValue llvmStruct | llvmValue -> llvmStruct where

An implementation of both MakeValueTuple and Memory.C must ensure that haskellValue is compatible with llvmStruct. That is, writing and reading llvmStruct by LLVM must be the same as accessing haskellValue by Storable methods. ToDo: In future we may also require Storable constraint for llvmStruct.

We use a functional dependency in order to let type inference work nicely.

Methods

load :: Value (Ptr llvmStruct) -> CodeGenFunction r llvmValue

store :: llvmValue -> Value (Ptr llvmStruct) -> CodeGenFunction r ()

decompose :: Value llvmStruct -> CodeGenFunction r llvmValue

compose :: llvmValue -> CodeGenFunction r (Value llvmStruct)

Instances

C () (Struct ())

IsFirstClass a => C (Value a) a

ToDo: This is dangerous because LLVM uses one bit for Bool representation, and I think one byte in memory, whereas Storable uses 4 byte and 4 byte alignment. We should define a sub-class of IsFirstClass for all compatible types, and make this a super-class of this instance.

(C al as, C bl bs, IsSized as sas, IsSized bs sbs) => C (al, bl) (Struct (as, (bs, ())))

(C al as, C bl bs, C cl cs, IsSized as sas, IsSized bs sbs, IsSized cs scs) => C (al, bl, cl) (Struct (as, (bs, (cs, ()))))

modify :: C llvmValue llvmStruct => (llvmValue -> CodeGenFunction r llvmValue) -> Value (Ptr llvmStruct) -> CodeGenFunction r ()

castStorablePtr :: (MakeValueTuple haskellValue llvmValue, C llvmValue llvmStruct) => Ptr haskellValue -> Ptr llvmStruct

type Record r o v = Element r o v v

data Element r o v x

Instances

Functor (Element r o v)

Applicative (Element r o v)

element :: (C x llvmStruct, GetValue o n llvmStruct, GetElementPtr o (n, ()) llvmStruct) => (v -> x) -> n -> Element r o v x

loadRecord :: Record r o llvmValue -> Value (Ptr o) -> CodeGenFunction r llvmValue

storeRecord :: Record r o llvmValue -> llvmValue -> Value (Ptr o) -> CodeGenFunction r ()

decomposeRecord :: Record r o llvmValue -> Value o -> CodeGenFunction r llvmValue

composeRecord :: IsType o => Record r o llvmValue -> llvmValue -> CodeGenFunction r (Value o)

loadNewtype :: C a o => (a -> llvmValue) -> Value (Ptr o) -> CodeGenFunction r llvmValue

storeNewtype :: C a o => (llvmValue -> a) -> llvmValue -> Value (Ptr o) -> CodeGenFunction r ()

decomposeNewtype :: C a o => (a -> llvmValue) -> Value o -> CodeGenFunction r llvmValue

composeNewtype :: C a o => (llvmValue -> a) -> llvmValue -> CodeGenFunction r (Value o)