{-# LANGUAGE TemplateHaskell, MultiParamTypeClasses, OverloadedStrings #-} module LLVM.Internal.Global where import LLVM.Prelude import Control.Monad.State import Control.Monad.AnyCont import Foreign.Ptr import qualified Data.Map as Map import qualified LLVM.Internal.FFI.PtrHierarchy as FFI import qualified LLVM.Internal.FFI.LLVMCTypes as FFI import qualified LLVM.Internal.FFI.GlobalValue as FFI import LLVM.Internal.Coding import LLVM.Internal.DecodeAST import LLVM.Internal.EncodeAST import qualified LLVM.AST.Linkage as A.L import qualified LLVM.AST.Visibility as A.V import qualified LLVM.AST.COMDAT as A.COMDAT import qualified LLVM.AST.DLL as A.DLL import qualified LLVM.AST.ThreadLocalStorage as A.TLS import qualified LLVM.AST.Global as A.G genCodingInstance [t| A.L.Linkage |] ''FFI.Linkage [ (FFI.linkageExternal, A.L.External), (FFI.linkageAvailableExternally, A.L.AvailableExternally), (FFI.linkageLinkOnceAny, A.L.LinkOnce), (FFI.linkageLinkOnceODR, A.L.LinkOnceODR), (FFI.linkageWeakAny, A.L.Weak), (FFI.linkageWeakODR, A.L.WeakODR), (FFI.linkageAppending, A.L.Appending), (FFI.linkageInternal, A.L.Internal), (FFI.linkagePrivate, A.L.Private), (FFI.linkageExternalWeak, A.L.ExternWeak), (FFI.linkageCommon, A.L.Common) ] getLinkage :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> DecodeAST A.L.Linkage getLinkage :: forall v. DescendentOf GlobalValue v => Ptr v -> DecodeAST Linkage getLinkage Ptr v g = IO Linkage -> DecodeAST Linkage forall a. IO a -> DecodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO Linkage -> DecodeAST Linkage) -> IO Linkage -> DecodeAST Linkage forall a b. (a -> b) -> a -> b $ Linkage -> IO Linkage forall (d :: * -> *) h c. (DecodeM d h c, HasCallStack) => c -> d h decodeM (Linkage -> IO Linkage) -> IO Linkage -> IO Linkage forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< Ptr GlobalValue -> IO Linkage FFI.getLinkage (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) setLinkage :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> A.L.Linkage -> EncodeAST () setLinkage :: forall v. DescendentOf GlobalValue v => Ptr v -> Linkage -> EncodeAST () setLinkage Ptr v g Linkage l = IO () -> EncodeAST () forall a. IO a -> EncodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO () -> EncodeAST ()) -> (Linkage -> IO ()) -> Linkage -> EncodeAST () forall b c a. (b -> c) -> (a -> b) -> a -> c . Ptr GlobalValue -> Linkage -> IO () FFI.setLinkage (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) (Linkage -> EncodeAST ()) -> EncodeAST Linkage -> EncodeAST () forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< Linkage -> EncodeAST Linkage forall (e :: * -> *) h c. (EncodeM e h c, HasCallStack) => h -> e c encodeM Linkage l genCodingInstance [t| A.V.Visibility |] ''FFI.Visibility [ (FFI.visibilityDefault, A.V.Default), (FFI.visibilityHidden, A.V.Hidden), (FFI.visibilityProtected, A.V.Protected) ] getVisibility :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> DecodeAST A.V.Visibility getVisibility :: forall v. DescendentOf GlobalValue v => Ptr v -> DecodeAST Visibility getVisibility Ptr v g = IO Visibility -> DecodeAST Visibility forall a. IO a -> DecodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO Visibility -> DecodeAST Visibility) -> IO Visibility -> DecodeAST Visibility forall a b. (a -> b) -> a -> b $ Visibility -> IO Visibility forall (d :: * -> *) h c. (DecodeM d h c, HasCallStack) => c -> d h decodeM (Visibility -> IO Visibility) -> IO Visibility -> IO Visibility forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< Ptr GlobalValue -> IO Visibility FFI.getVisibility (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) setVisibility :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> A.V.Visibility -> EncodeAST () setVisibility :: forall v. DescendentOf GlobalValue v => Ptr v -> Visibility -> EncodeAST () setVisibility Ptr v g Visibility v = IO () -> EncodeAST () forall a. IO a -> EncodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO () -> EncodeAST ()) -> (Visibility -> IO ()) -> Visibility -> EncodeAST () forall b c a. (b -> c) -> (a -> b) -> a -> c . Ptr GlobalValue -> Visibility -> IO () FFI.setVisibility (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) (Visibility -> EncodeAST ()) -> EncodeAST Visibility -> EncodeAST () forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< Visibility -> EncodeAST Visibility forall (e :: * -> *) h c. (EncodeM e h c, HasCallStack) => h -> e c encodeM Visibility v genCodingInstance [t| Maybe A.DLL.StorageClass |] ''FFI.DLLStorageClass [ (FFI.dllStorageClassDefault, Nothing), (FFI.dllStorageClassDLLImport, Just A.DLL.Import), (FFI.dllStorageClassDLLExport, Just A.DLL.Export) ] getDLLStorageClass :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> DecodeAST (Maybe A.DLL.StorageClass) getDLLStorageClass :: forall v. DescendentOf GlobalValue v => Ptr v -> DecodeAST (Maybe StorageClass) getDLLStorageClass Ptr v g = IO (Maybe StorageClass) -> DecodeAST (Maybe StorageClass) forall a. IO a -> DecodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO (Maybe StorageClass) -> DecodeAST (Maybe StorageClass)) -> IO (Maybe StorageClass) -> DecodeAST (Maybe StorageClass) forall a b. (a -> b) -> a -> b $ DLLStorageClass -> IO (Maybe StorageClass) forall (d :: * -> *) h c. (DecodeM d h c, HasCallStack) => c -> d h decodeM (DLLStorageClass -> IO (Maybe StorageClass)) -> IO DLLStorageClass -> IO (Maybe StorageClass) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< Ptr GlobalValue -> IO DLLStorageClass FFI.getDLLStorageClass (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) setDLLStorageClass :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> Maybe A.DLL.StorageClass -> EncodeAST () setDLLStorageClass :: forall v. DescendentOf GlobalValue v => Ptr v -> Maybe StorageClass -> EncodeAST () setDLLStorageClass Ptr v g Maybe StorageClass sc = IO () -> EncodeAST () forall a. IO a -> EncodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO () -> EncodeAST ()) -> (DLLStorageClass -> IO ()) -> DLLStorageClass -> EncodeAST () forall b c a. (b -> c) -> (a -> b) -> a -> c . Ptr GlobalValue -> DLLStorageClass -> IO () FFI.setDLLStorageClass (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) (DLLStorageClass -> EncodeAST ()) -> EncodeAST DLLStorageClass -> EncodeAST () forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< Maybe StorageClass -> EncodeAST DLLStorageClass forall (e :: * -> *) h c. (EncodeM e h c, HasCallStack) => h -> e c encodeM Maybe StorageClass sc getSection :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> DecodeAST (Maybe ShortByteString) getSection :: forall v. DescendentOf GlobalValue v => Ptr v -> DecodeAST (Maybe ShortByteString) getSection Ptr v g = do Ptr CSize sectionLengthPtr <- DecodeAST (Ptr CSize) forall a (m :: * -> *). (Storable a, MonadAnyCont IO m) => m (Ptr a) alloca CString sectionNamePtr <- IO CString -> DecodeAST CString forall a. IO a -> DecodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO CString -> DecodeAST CString) -> IO CString -> DecodeAST CString forall a b. (a -> b) -> a -> b $ Ptr GlobalValue -> Ptr CSize -> IO CString FFI.getSection (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) Ptr CSize sectionLengthPtr if CString sectionNamePtr CString -> CString -> Bool forall a. Eq a => a -> a -> Bool == CString forall a. Ptr a nullPtr then Maybe ShortByteString -> DecodeAST (Maybe ShortByteString) forall a. a -> DecodeAST a forall (m :: * -> *) a. Monad m => a -> m a return Maybe ShortByteString forall a. Maybe a Nothing else do CSize sectionLength <- Ptr CSize -> DecodeAST CSize forall a (m :: * -> *). (Storable a, MonadIO m) => Ptr a -> m a peek Ptr CSize sectionLengthPtr ShortByteString sectionName <- (CString, CSize) -> DecodeAST ShortByteString forall (d :: * -> *) h c. (DecodeM d h c, HasCallStack) => c -> d h decodeM (CString sectionNamePtr, CSize sectionLength) Maybe ShortByteString -> DecodeAST (Maybe ShortByteString) forall a. a -> DecodeAST a forall (m :: * -> *) a. Monad m => a -> m a return (ShortByteString -> Maybe ShortByteString forall a. a -> Maybe a Just ShortByteString sectionName) setSection :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> Maybe ShortByteString -> EncodeAST () setSection :: forall v. DescendentOf GlobalValue v => Ptr v -> Maybe ShortByteString -> EncodeAST () setSection Ptr v g Maybe ShortByteString s = EncodeAST () -> EncodeAST () forall a. EncodeAST a -> EncodeAST a forall (m :: * -> *) a. ScopeAnyCont m => m a -> m a scopeAnyCont (EncodeAST () -> EncodeAST ()) -> EncodeAST () -> EncodeAST () forall a b. (a -> b) -> a -> b $ do CString s <- ShortByteString -> EncodeAST CString forall (e :: * -> *) h c. (EncodeM e h c, HasCallStack) => h -> e c encodeM (ShortByteString -> Maybe ShortByteString -> ShortByteString forall a. a -> Maybe a -> a fromMaybe ShortByteString "" Maybe ShortByteString s) IO () -> EncodeAST () forall a. IO a -> EncodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO () -> EncodeAST ()) -> IO () -> EncodeAST () forall a b. (a -> b) -> a -> b $ Ptr GlobalValue -> CString -> IO () FFI.setSection (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) CString s genCodingInstance [t| A.COMDAT.SelectionKind |] ''FFI.COMDATSelectionKind [ (FFI.comdatSelectionKindAny, A.COMDAT.Any), (FFI.comdatSelectionKindExactMatch, A.COMDAT.ExactMatch), (FFI.comdatSelectionKindLargest, A.COMDAT.Largest), (FFI.comdatSelectionKindNoDuplicates, A.COMDAT.NoDuplicates), (FFI.comdatSelectionKindSameSize, A.COMDAT.SameSize) ] instance DecodeM DecodeAST (ShortByteString, A.COMDAT.SelectionKind) (Ptr FFI.COMDAT) where decodeM :: HasCallStack => Ptr COMDAT -> DecodeAST (ShortByteString, SelectionKind) decodeM Ptr COMDAT c = (,) (ShortByteString -> SelectionKind -> (ShortByteString, SelectionKind)) -> DecodeAST ShortByteString -> DecodeAST (SelectionKind -> (ShortByteString, SelectionKind)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> (Ptr CSize -> IO CString) -> DecodeAST ShortByteString forall (d :: * -> *) h c. (DecodeM d h c, HasCallStack) => c -> d h decodeM (Ptr COMDAT -> Ptr CSize -> IO CString FFI.getCOMDATName Ptr COMDAT c) DecodeAST (SelectionKind -> (ShortByteString, SelectionKind)) -> DecodeAST SelectionKind -> DecodeAST (ShortByteString, SelectionKind) forall a b. DecodeAST (a -> b) -> DecodeAST a -> DecodeAST b forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b <*> (COMDATSelectionKind -> DecodeAST SelectionKind forall (d :: * -> *) h c. (DecodeM d h c, HasCallStack) => c -> d h decodeM (COMDATSelectionKind -> DecodeAST SelectionKind) -> DecodeAST COMDATSelectionKind -> DecodeAST SelectionKind forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< IO COMDATSelectionKind -> DecodeAST COMDATSelectionKind forall a. IO a -> DecodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (Ptr COMDAT -> IO COMDATSelectionKind FFI.getCOMDATSelectionKind Ptr COMDAT c)) getCOMDATName :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> DecodeAST (Maybe ShortByteString) getCOMDATName :: forall v. DescendentOf GlobalValue v => Ptr v -> DecodeAST (Maybe ShortByteString) getCOMDATName Ptr v g = do Ptr COMDAT c <- IO (Ptr COMDAT) -> DecodeAST (Ptr COMDAT) forall a. IO a -> DecodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO (Ptr COMDAT) -> DecodeAST (Ptr COMDAT)) -> IO (Ptr COMDAT) -> DecodeAST (Ptr COMDAT) forall a b. (a -> b) -> a -> b $ Ptr GlobalValue -> IO (Ptr COMDAT) FFI.getCOMDAT (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) if Ptr COMDAT c Ptr COMDAT -> Ptr COMDAT -> Bool forall a. Eq a => a -> a -> Bool == Ptr COMDAT forall a. Ptr a nullPtr then Maybe ShortByteString -> DecodeAST (Maybe ShortByteString) forall a. a -> DecodeAST a forall (m :: * -> *) a. Monad m => a -> m a return Maybe ShortByteString forall a. Maybe a Nothing else do Map (Ptr COMDAT) (ShortByteString, SelectionKind) cds <- (DecodeState -> Map (Ptr COMDAT) (ShortByteString, SelectionKind)) -> DecodeAST (Map (Ptr COMDAT) (ShortByteString, SelectionKind)) forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a gets DecodeState -> Map (Ptr COMDAT) (ShortByteString, SelectionKind) comdats (ShortByteString -> Maybe ShortByteString) -> DecodeAST ShortByteString -> DecodeAST (Maybe ShortByteString) forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r liftM ShortByteString -> Maybe ShortByteString forall a. a -> Maybe a Just (DecodeAST ShortByteString -> DecodeAST (Maybe ShortByteString)) -> DecodeAST ShortByteString -> DecodeAST (Maybe ShortByteString) forall a b. (a -> b) -> a -> b $ case Ptr COMDAT -> Map (Ptr COMDAT) (ShortByteString, SelectionKind) -> Maybe (ShortByteString, SelectionKind) forall k a. Ord k => k -> Map k a -> Maybe a Map.lookup Ptr COMDAT c Map (Ptr COMDAT) (ShortByteString, SelectionKind) cds of Just (ShortByteString name, SelectionKind _) -> ShortByteString -> DecodeAST ShortByteString forall a. a -> DecodeAST a forall (m :: * -> *) a. Monad m => a -> m a return ShortByteString name Maybe (ShortByteString, SelectionKind) Nothing -> do cd :: (ShortByteString, SelectionKind) cd@(ShortByteString name, SelectionKind _) <- Ptr COMDAT -> DecodeAST (ShortByteString, SelectionKind) forall (d :: * -> *) h c. (DecodeM d h c, HasCallStack) => c -> d h decodeM Ptr COMDAT c (DecodeState -> DecodeState) -> DecodeAST () forall s (m :: * -> *). MonadState s m => (s -> s) -> m () modify ((DecodeState -> DecodeState) -> DecodeAST ()) -> (DecodeState -> DecodeState) -> DecodeAST () forall a b. (a -> b) -> a -> b $ \DecodeState s -> DecodeState s { comdats :: Map (Ptr COMDAT) (ShortByteString, SelectionKind) comdats = Ptr COMDAT -> (ShortByteString, SelectionKind) -> Map (Ptr COMDAT) (ShortByteString, SelectionKind) -> Map (Ptr COMDAT) (ShortByteString, SelectionKind) forall k a. Ord k => k -> a -> Map k a -> Map k a Map.insert Ptr COMDAT c (ShortByteString, SelectionKind) cd Map (Ptr COMDAT) (ShortByteString, SelectionKind) cds } ShortByteString -> DecodeAST ShortByteString forall a. a -> DecodeAST a forall (m :: * -> *) a. Monad m => a -> m a return ShortByteString name setCOMDAT :: FFI.DescendentOf FFI.GlobalObject v => Ptr v -> Maybe ShortByteString -> EncodeAST () setCOMDAT :: forall v. DescendentOf GlobalObject v => Ptr v -> Maybe ShortByteString -> EncodeAST () setCOMDAT Ptr v _ Maybe ShortByteString Nothing = () -> EncodeAST () forall a. a -> EncodeAST a forall (m :: * -> *) a. Monad m => a -> m a return () setCOMDAT Ptr v g (Just ShortByteString name) = do Ptr COMDAT cd <- ShortByteString -> EncodeAST (Ptr COMDAT) referCOMDAT ShortByteString name IO () -> EncodeAST () forall a. IO a -> EncodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO () -> EncodeAST ()) -> IO () -> EncodeAST () forall a b. (a -> b) -> a -> b $ Ptr GlobalObject -> Ptr COMDAT -> IO () FFI.setCOMDAT (Ptr v -> Ptr GlobalObject forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) Ptr COMDAT cd setAlignment :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> Word32 -> EncodeAST () setAlignment :: forall v. DescendentOf GlobalValue v => Ptr v -> Word32 -> EncodeAST () setAlignment Ptr v g Word32 i = IO () -> EncodeAST () forall a. IO a -> EncodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO () -> EncodeAST ()) -> IO () -> EncodeAST () forall a b. (a -> b) -> a -> b $ Ptr GlobalValue -> CUInt -> IO () FFI.setAlignment (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) (Word32 -> CUInt forall a b. (Integral a, Num b) => a -> b fromIntegral Word32 i) getAlignment :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> DecodeAST Word32 getAlignment :: forall v. DescendentOf GlobalValue v => Ptr v -> DecodeAST Word32 getAlignment Ptr v g = IO Word32 -> DecodeAST Word32 forall a. IO a -> DecodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO Word32 -> DecodeAST Word32) -> IO Word32 -> DecodeAST Word32 forall a b. (a -> b) -> a -> b $ CUInt -> Word32 forall a b. (Integral a, Num b) => a -> b fromIntegral (CUInt -> Word32) -> IO CUInt -> IO Word32 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Ptr GlobalValue -> IO CUInt FFI.getAlignment (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) genCodingInstance [t| Maybe A.TLS.Model |] ''FFI.ThreadLocalMode [ (FFI.threadLocalModeNotThreadLocal, Nothing), (FFI.threadLocalModeGeneralDynamicTLSModel, Just A.TLS.GeneralDynamic), (FFI.threadLocalModeLocalDynamicTLSModel, Just A.TLS.LocalDynamic), (FFI.threadLocalModeInitialExecTLSModel, Just A.TLS.InitialExec), (FFI.threadLocalModeLocalExecTLSModel, Just A.TLS.LocalExec) ] getThreadLocalMode :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> DecodeAST (Maybe A.TLS.Model) getThreadLocalMode :: forall v. DescendentOf GlobalValue v => Ptr v -> DecodeAST (Maybe Model) getThreadLocalMode Ptr v g = IO (Maybe Model) -> DecodeAST (Maybe Model) forall a. IO a -> DecodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO (Maybe Model) -> DecodeAST (Maybe Model)) -> IO (Maybe Model) -> DecodeAST (Maybe Model) forall a b. (a -> b) -> a -> b $ ThreadLocalMode -> IO (Maybe Model) forall (d :: * -> *) h c. (DecodeM d h c, HasCallStack) => c -> d h decodeM (ThreadLocalMode -> IO (Maybe Model)) -> IO ThreadLocalMode -> IO (Maybe Model) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< Ptr GlobalValue -> IO ThreadLocalMode FFI.getThreadLocalMode (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) setThreadLocalMode :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> Maybe A.TLS.Model -> EncodeAST () setThreadLocalMode :: forall v. DescendentOf GlobalValue v => Ptr v -> Maybe Model -> EncodeAST () setThreadLocalMode Ptr v g Maybe Model m = IO () -> EncodeAST () forall a. IO a -> EncodeAST a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO (IO () -> EncodeAST ()) -> (ThreadLocalMode -> IO ()) -> ThreadLocalMode -> EncodeAST () forall b c a. (b -> c) -> (a -> b) -> a -> c . Ptr GlobalValue -> ThreadLocalMode -> IO () FFI.setThreadLocalMode (Ptr v -> Ptr GlobalValue forall a b. DescendentOf a b => Ptr b -> Ptr a FFI.upCast Ptr v g) (ThreadLocalMode -> EncodeAST ()) -> EncodeAST ThreadLocalMode -> EncodeAST () forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b =<< Maybe Model -> EncodeAST ThreadLocalMode forall (e :: * -> *) h c. (EncodeM e h c, HasCallStack) => h -> e c encodeM Maybe Model m genCodingInstance [t| Maybe A.G.UnnamedAddr |] ''FFI.UnnamedAddr [ (FFI.unnamedAddrNo, Nothing), (FFI.unnamedAddrLocal, Just A.G.LocalAddr), (FFI.unnamedAddrGlobal, Just A.G.GlobalAddr) ]