-- | <http://llvm.org/docs/LangRef.html#data-layout>
module LLVM.AST.DataLayout where

import LLVM.Prelude

import Data.Map (Map)
import qualified Data.Map as Map
import Data.Set (Set)

import LLVM.AST.AddrSpace

-- | Little Endian is the one true way :-). Sadly, we must support the infidels.
data Endianness = LittleEndian | BigEndian
  deriving (Endianness -> Endianness -> Bool
(Endianness -> Endianness -> Bool)
-> (Endianness -> Endianness -> Bool) -> Eq Endianness
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Endianness -> Endianness -> Bool
== :: Endianness -> Endianness -> Bool
$c/= :: Endianness -> Endianness -> Bool
/= :: Endianness -> Endianness -> Bool
Eq, Eq Endianness
Eq Endianness
-> (Endianness -> Endianness -> Ordering)
-> (Endianness -> Endianness -> Bool)
-> (Endianness -> Endianness -> Bool)
-> (Endianness -> Endianness -> Bool)
-> (Endianness -> Endianness -> Bool)
-> (Endianness -> Endianness -> Endianness)
-> (Endianness -> Endianness -> Endianness)
-> Ord Endianness
Endianness -> Endianness -> Bool
Endianness -> Endianness -> Ordering
Endianness -> Endianness -> Endianness
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Endianness -> Endianness -> Ordering
compare :: Endianness -> Endianness -> Ordering
$c< :: Endianness -> Endianness -> Bool
< :: Endianness -> Endianness -> Bool
$c<= :: Endianness -> Endianness -> Bool
<= :: Endianness -> Endianness -> Bool
$c> :: Endianness -> Endianness -> Bool
> :: Endianness -> Endianness -> Bool
$c>= :: Endianness -> Endianness -> Bool
>= :: Endianness -> Endianness -> Bool
$cmax :: Endianness -> Endianness -> Endianness
max :: Endianness -> Endianness -> Endianness
$cmin :: Endianness -> Endianness -> Endianness
min :: Endianness -> Endianness -> Endianness
Ord, ReadPrec [Endianness]
ReadPrec Endianness
Int -> ReadS Endianness
ReadS [Endianness]
(Int -> ReadS Endianness)
-> ReadS [Endianness]
-> ReadPrec Endianness
-> ReadPrec [Endianness]
-> Read Endianness
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Endianness
readsPrec :: Int -> ReadS Endianness
$creadList :: ReadS [Endianness]
readList :: ReadS [Endianness]
$creadPrec :: ReadPrec Endianness
readPrec :: ReadPrec Endianness
$creadListPrec :: ReadPrec [Endianness]
readListPrec :: ReadPrec [Endianness]
Read, Int -> Endianness -> ShowS
[Endianness] -> ShowS
Endianness -> String
(Int -> Endianness -> ShowS)
-> (Endianness -> String)
-> ([Endianness] -> ShowS)
-> Show Endianness
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Endianness -> ShowS
showsPrec :: Int -> Endianness -> ShowS
$cshow :: Endianness -> String
show :: Endianness -> String
$cshowList :: [Endianness] -> ShowS
showList :: [Endianness] -> ShowS
Show, Typeable, Typeable Endianness
Typeable Endianness
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Endianness -> c Endianness)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Endianness)
-> (Endianness -> Constr)
-> (Endianness -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Endianness))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Endianness))
-> ((forall b. Data b => b -> b) -> Endianness -> Endianness)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Endianness -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Endianness -> r)
-> (forall u. (forall d. Data d => d -> u) -> Endianness -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Endianness -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Endianness -> m Endianness)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Endianness -> m Endianness)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Endianness -> m Endianness)
-> Data Endianness
Endianness -> Constr
Endianness -> DataType
(forall b. Data b => b -> b) -> Endianness -> Endianness
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Endianness -> u
forall u. (forall d. Data d => d -> u) -> Endianness -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Endianness -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Endianness -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Endianness -> m Endianness
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Endianness -> m Endianness
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Endianness
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Endianness -> c Endianness
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Endianness)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Endianness)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Endianness -> c Endianness
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Endianness -> c Endianness
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Endianness
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Endianness
$ctoConstr :: Endianness -> Constr
toConstr :: Endianness -> Constr
$cdataTypeOf :: Endianness -> DataType
dataTypeOf :: Endianness -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Endianness)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Endianness)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Endianness)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Endianness)
$cgmapT :: (forall b. Data b => b -> b) -> Endianness -> Endianness
gmapT :: (forall b. Data b => b -> b) -> Endianness -> Endianness
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Endianness -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Endianness -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Endianness -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Endianness -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Endianness -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Endianness -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Endianness -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Endianness -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Endianness -> m Endianness
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Endianness -> m Endianness
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Endianness -> m Endianness
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Endianness -> m Endianness
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Endianness -> m Endianness
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Endianness -> m Endianness
Data, (forall x. Endianness -> Rep Endianness x)
-> (forall x. Rep Endianness x -> Endianness) -> Generic Endianness
forall x. Rep Endianness x -> Endianness
forall x. Endianness -> Rep Endianness x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Endianness -> Rep Endianness x
from :: forall x. Endianness -> Rep Endianness x
$cto :: forall x. Rep Endianness x -> Endianness
to :: forall x. Rep Endianness x -> Endianness
Generic)

-- | An AlignmentInfo describes how a given type must and would best be aligned
data AlignmentInfo = AlignmentInfo {
    AlignmentInfo -> Word32
abiAlignment :: Word32,
    AlignmentInfo -> Word32
preferredAlignment :: Word32
  }
  deriving (AlignmentInfo -> AlignmentInfo -> Bool
(AlignmentInfo -> AlignmentInfo -> Bool)
-> (AlignmentInfo -> AlignmentInfo -> Bool) -> Eq AlignmentInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AlignmentInfo -> AlignmentInfo -> Bool
== :: AlignmentInfo -> AlignmentInfo -> Bool
$c/= :: AlignmentInfo -> AlignmentInfo -> Bool
/= :: AlignmentInfo -> AlignmentInfo -> Bool
Eq, Eq AlignmentInfo
Eq AlignmentInfo
-> (AlignmentInfo -> AlignmentInfo -> Ordering)
-> (AlignmentInfo -> AlignmentInfo -> Bool)
-> (AlignmentInfo -> AlignmentInfo -> Bool)
-> (AlignmentInfo -> AlignmentInfo -> Bool)
-> (AlignmentInfo -> AlignmentInfo -> Bool)
-> (AlignmentInfo -> AlignmentInfo -> AlignmentInfo)
-> (AlignmentInfo -> AlignmentInfo -> AlignmentInfo)
-> Ord AlignmentInfo
AlignmentInfo -> AlignmentInfo -> Bool
AlignmentInfo -> AlignmentInfo -> Ordering
AlignmentInfo -> AlignmentInfo -> AlignmentInfo
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AlignmentInfo -> AlignmentInfo -> Ordering
compare :: AlignmentInfo -> AlignmentInfo -> Ordering
$c< :: AlignmentInfo -> AlignmentInfo -> Bool
< :: AlignmentInfo -> AlignmentInfo -> Bool
$c<= :: AlignmentInfo -> AlignmentInfo -> Bool
<= :: AlignmentInfo -> AlignmentInfo -> Bool
$c> :: AlignmentInfo -> AlignmentInfo -> Bool
> :: AlignmentInfo -> AlignmentInfo -> Bool
$c>= :: AlignmentInfo -> AlignmentInfo -> Bool
>= :: AlignmentInfo -> AlignmentInfo -> Bool
$cmax :: AlignmentInfo -> AlignmentInfo -> AlignmentInfo
max :: AlignmentInfo -> AlignmentInfo -> AlignmentInfo
$cmin :: AlignmentInfo -> AlignmentInfo -> AlignmentInfo
min :: AlignmentInfo -> AlignmentInfo -> AlignmentInfo
Ord, ReadPrec [AlignmentInfo]
ReadPrec AlignmentInfo
Int -> ReadS AlignmentInfo
ReadS [AlignmentInfo]
(Int -> ReadS AlignmentInfo)
-> ReadS [AlignmentInfo]
-> ReadPrec AlignmentInfo
-> ReadPrec [AlignmentInfo]
-> Read AlignmentInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AlignmentInfo
readsPrec :: Int -> ReadS AlignmentInfo
$creadList :: ReadS [AlignmentInfo]
readList :: ReadS [AlignmentInfo]
$creadPrec :: ReadPrec AlignmentInfo
readPrec :: ReadPrec AlignmentInfo
$creadListPrec :: ReadPrec [AlignmentInfo]
readListPrec :: ReadPrec [AlignmentInfo]
Read, Int -> AlignmentInfo -> ShowS
[AlignmentInfo] -> ShowS
AlignmentInfo -> String
(Int -> AlignmentInfo -> ShowS)
-> (AlignmentInfo -> String)
-> ([AlignmentInfo] -> ShowS)
-> Show AlignmentInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AlignmentInfo -> ShowS
showsPrec :: Int -> AlignmentInfo -> ShowS
$cshow :: AlignmentInfo -> String
show :: AlignmentInfo -> String
$cshowList :: [AlignmentInfo] -> ShowS
showList :: [AlignmentInfo] -> ShowS
Show, Typeable, Typeable AlignmentInfo
Typeable AlignmentInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AlignmentInfo -> c AlignmentInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AlignmentInfo)
-> (AlignmentInfo -> Constr)
-> (AlignmentInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AlignmentInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AlignmentInfo))
-> ((forall b. Data b => b -> b) -> AlignmentInfo -> AlignmentInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AlignmentInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AlignmentInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> AlignmentInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AlignmentInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo)
-> Data AlignmentInfo
AlignmentInfo -> Constr
AlignmentInfo -> DataType
(forall b. Data b => b -> b) -> AlignmentInfo -> AlignmentInfo
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> AlignmentInfo -> u
forall u. (forall d. Data d => d -> u) -> AlignmentInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlignmentInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlignmentInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlignmentInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignmentInfo -> c AlignmentInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlignmentInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlignmentInfo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignmentInfo -> c AlignmentInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignmentInfo -> c AlignmentInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlignmentInfo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlignmentInfo
$ctoConstr :: AlignmentInfo -> Constr
toConstr :: AlignmentInfo -> Constr
$cdataTypeOf :: AlignmentInfo -> DataType
dataTypeOf :: AlignmentInfo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlignmentInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlignmentInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlignmentInfo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlignmentInfo)
$cgmapT :: (forall b. Data b => b -> b) -> AlignmentInfo -> AlignmentInfo
gmapT :: (forall b. Data b => b -> b) -> AlignmentInfo -> AlignmentInfo
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlignmentInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlignmentInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlignmentInfo -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlignmentInfo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AlignmentInfo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AlignmentInfo -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AlignmentInfo -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AlignmentInfo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo
Data, (forall x. AlignmentInfo -> Rep AlignmentInfo x)
-> (forall x. Rep AlignmentInfo x -> AlignmentInfo)
-> Generic AlignmentInfo
forall x. Rep AlignmentInfo x -> AlignmentInfo
forall x. AlignmentInfo -> Rep AlignmentInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AlignmentInfo -> Rep AlignmentInfo x
from :: forall x. AlignmentInfo -> Rep AlignmentInfo x
$cto :: forall x. Rep AlignmentInfo x -> AlignmentInfo
to :: forall x. Rep AlignmentInfo x -> AlignmentInfo
Generic)

-- | A type of type for which 'AlignmentInfo' may be specified
data AlignType
  = IntegerAlign
  | VectorAlign
  | FloatAlign
  deriving (AlignType -> AlignType -> Bool
(AlignType -> AlignType -> Bool)
-> (AlignType -> AlignType -> Bool) -> Eq AlignType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AlignType -> AlignType -> Bool
== :: AlignType -> AlignType -> Bool
$c/= :: AlignType -> AlignType -> Bool
/= :: AlignType -> AlignType -> Bool
Eq, Eq AlignType
Eq AlignType
-> (AlignType -> AlignType -> Ordering)
-> (AlignType -> AlignType -> Bool)
-> (AlignType -> AlignType -> Bool)
-> (AlignType -> AlignType -> Bool)
-> (AlignType -> AlignType -> Bool)
-> (AlignType -> AlignType -> AlignType)
-> (AlignType -> AlignType -> AlignType)
-> Ord AlignType
AlignType -> AlignType -> Bool
AlignType -> AlignType -> Ordering
AlignType -> AlignType -> AlignType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AlignType -> AlignType -> Ordering
compare :: AlignType -> AlignType -> Ordering
$c< :: AlignType -> AlignType -> Bool
< :: AlignType -> AlignType -> Bool
$c<= :: AlignType -> AlignType -> Bool
<= :: AlignType -> AlignType -> Bool
$c> :: AlignType -> AlignType -> Bool
> :: AlignType -> AlignType -> Bool
$c>= :: AlignType -> AlignType -> Bool
>= :: AlignType -> AlignType -> Bool
$cmax :: AlignType -> AlignType -> AlignType
max :: AlignType -> AlignType -> AlignType
$cmin :: AlignType -> AlignType -> AlignType
min :: AlignType -> AlignType -> AlignType
Ord, ReadPrec [AlignType]
ReadPrec AlignType
Int -> ReadS AlignType
ReadS [AlignType]
(Int -> ReadS AlignType)
-> ReadS [AlignType]
-> ReadPrec AlignType
-> ReadPrec [AlignType]
-> Read AlignType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AlignType
readsPrec :: Int -> ReadS AlignType
$creadList :: ReadS [AlignType]
readList :: ReadS [AlignType]
$creadPrec :: ReadPrec AlignType
readPrec :: ReadPrec AlignType
$creadListPrec :: ReadPrec [AlignType]
readListPrec :: ReadPrec [AlignType]
Read, Int -> AlignType -> ShowS
[AlignType] -> ShowS
AlignType -> String
(Int -> AlignType -> ShowS)
-> (AlignType -> String)
-> ([AlignType] -> ShowS)
-> Show AlignType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AlignType -> ShowS
showsPrec :: Int -> AlignType -> ShowS
$cshow :: AlignType -> String
show :: AlignType -> String
$cshowList :: [AlignType] -> ShowS
showList :: [AlignType] -> ShowS
Show, Typeable, Typeable AlignType
Typeable AlignType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AlignType -> c AlignType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AlignType)
-> (AlignType -> Constr)
-> (AlignType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AlignType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlignType))
-> ((forall b. Data b => b -> b) -> AlignType -> AlignType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AlignType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AlignType -> r)
-> (forall u. (forall d. Data d => d -> u) -> AlignType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AlignType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AlignType -> m AlignType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AlignType -> m AlignType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AlignType -> m AlignType)
-> Data AlignType
AlignType -> Constr
AlignType -> DataType
(forall b. Data b => b -> b) -> AlignType -> AlignType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> AlignType -> u
forall u. (forall d. Data d => d -> u) -> AlignType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlignType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlignType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AlignType -> m AlignType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlignType -> m AlignType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlignType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignType -> c AlignType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlignType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlignType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignType -> c AlignType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignType -> c AlignType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlignType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlignType
$ctoConstr :: AlignType -> Constr
toConstr :: AlignType -> Constr
$cdataTypeOf :: AlignType -> DataType
dataTypeOf :: AlignType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlignType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlignType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlignType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlignType)
$cgmapT :: (forall b. Data b => b -> b) -> AlignType -> AlignType
gmapT :: (forall b. Data b => b -> b) -> AlignType -> AlignType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlignType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlignType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlignType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlignType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AlignType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AlignType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AlignType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AlignType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AlignType -> m AlignType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AlignType -> m AlignType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlignType -> m AlignType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlignType -> m AlignType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlignType -> m AlignType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlignType -> m AlignType
Data, (forall x. AlignType -> Rep AlignType x)
-> (forall x. Rep AlignType x -> AlignType) -> Generic AlignType
forall x. Rep AlignType x -> AlignType
forall x. AlignType -> Rep AlignType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AlignType -> Rep AlignType x
from :: forall x. AlignType -> Rep AlignType x
$cto :: forall x. Rep AlignType x -> AlignType
to :: forall x. Rep AlignType x -> AlignType
Generic)

-- | A style of name mangling
data Mangling
  = ELFMangling
  | MIPSMangling
  | MachOMangling
  | WindowsCOFFMangling
  deriving (Mangling -> Mangling -> Bool
(Mangling -> Mangling -> Bool)
-> (Mangling -> Mangling -> Bool) -> Eq Mangling
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Mangling -> Mangling -> Bool
== :: Mangling -> Mangling -> Bool
$c/= :: Mangling -> Mangling -> Bool
/= :: Mangling -> Mangling -> Bool
Eq, Eq Mangling
Eq Mangling
-> (Mangling -> Mangling -> Ordering)
-> (Mangling -> Mangling -> Bool)
-> (Mangling -> Mangling -> Bool)
-> (Mangling -> Mangling -> Bool)
-> (Mangling -> Mangling -> Bool)
-> (Mangling -> Mangling -> Mangling)
-> (Mangling -> Mangling -> Mangling)
-> Ord Mangling
Mangling -> Mangling -> Bool
Mangling -> Mangling -> Ordering
Mangling -> Mangling -> Mangling
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Mangling -> Mangling -> Ordering
compare :: Mangling -> Mangling -> Ordering
$c< :: Mangling -> Mangling -> Bool
< :: Mangling -> Mangling -> Bool
$c<= :: Mangling -> Mangling -> Bool
<= :: Mangling -> Mangling -> Bool
$c> :: Mangling -> Mangling -> Bool
> :: Mangling -> Mangling -> Bool
$c>= :: Mangling -> Mangling -> Bool
>= :: Mangling -> Mangling -> Bool
$cmax :: Mangling -> Mangling -> Mangling
max :: Mangling -> Mangling -> Mangling
$cmin :: Mangling -> Mangling -> Mangling
min :: Mangling -> Mangling -> Mangling
Ord, ReadPrec [Mangling]
ReadPrec Mangling
Int -> ReadS Mangling
ReadS [Mangling]
(Int -> ReadS Mangling)
-> ReadS [Mangling]
-> ReadPrec Mangling
-> ReadPrec [Mangling]
-> Read Mangling
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Mangling
readsPrec :: Int -> ReadS Mangling
$creadList :: ReadS [Mangling]
readList :: ReadS [Mangling]
$creadPrec :: ReadPrec Mangling
readPrec :: ReadPrec Mangling
$creadListPrec :: ReadPrec [Mangling]
readListPrec :: ReadPrec [Mangling]
Read, Int -> Mangling -> ShowS
[Mangling] -> ShowS
Mangling -> String
(Int -> Mangling -> ShowS)
-> (Mangling -> String) -> ([Mangling] -> ShowS) -> Show Mangling
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Mangling -> ShowS
showsPrec :: Int -> Mangling -> ShowS
$cshow :: Mangling -> String
show :: Mangling -> String
$cshowList :: [Mangling] -> ShowS
showList :: [Mangling] -> ShowS
Show, Typeable, Typeable Mangling
Typeable Mangling
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Mangling -> c Mangling)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Mangling)
-> (Mangling -> Constr)
-> (Mangling -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Mangling))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mangling))
-> ((forall b. Data b => b -> b) -> Mangling -> Mangling)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Mangling -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Mangling -> r)
-> (forall u. (forall d. Data d => d -> u) -> Mangling -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Mangling -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Mangling -> m Mangling)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Mangling -> m Mangling)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Mangling -> m Mangling)
-> Data Mangling
Mangling -> Constr
Mangling -> DataType
(forall b. Data b => b -> b) -> Mangling -> Mangling
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Mangling -> u
forall u. (forall d. Data d => d -> u) -> Mangling -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mangling
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mangling -> c Mangling
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mangling)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mangling)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mangling -> c Mangling
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mangling -> c Mangling
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mangling
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mangling
$ctoConstr :: Mangling -> Constr
toConstr :: Mangling -> Constr
$cdataTypeOf :: Mangling -> DataType
dataTypeOf :: Mangling -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mangling)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mangling)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mangling)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mangling)
$cgmapT :: (forall b. Data b => b -> b) -> Mangling -> Mangling
gmapT :: (forall b. Data b => b -> b) -> Mangling -> Mangling
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Mangling -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Mangling -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Mangling -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Mangling -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
Data, (forall x. Mangling -> Rep Mangling x)
-> (forall x. Rep Mangling x -> Mangling) -> Generic Mangling
forall x. Rep Mangling x -> Mangling
forall x. Mangling -> Rep Mangling x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Mangling -> Rep Mangling x
from :: forall x. Mangling -> Rep Mangling x
$cto :: forall x. Rep Mangling x -> Mangling
to :: forall x. Rep Mangling x -> Mangling
Generic)

-- | a description of the various data layout properties which may be used during
-- optimization
data DataLayout = DataLayout {
    DataLayout -> Endianness
endianness :: Endianness,
    DataLayout -> Maybe Mangling
mangling :: Maybe Mangling,
    DataLayout -> Maybe Word32
stackAlignment :: Maybe Word32,
    DataLayout -> Map AddrSpace (Word32, AlignmentInfo)
pointerLayouts :: Map AddrSpace (Word32, AlignmentInfo),
    DataLayout -> Map (AlignType, Word32) AlignmentInfo
typeLayouts :: Map (AlignType, Word32) AlignmentInfo,
    DataLayout -> AlignmentInfo
aggregateLayout :: AlignmentInfo,
    DataLayout -> Maybe (Set Word32)
nativeSizes :: Maybe (Set Word32)
  }
  deriving (DataLayout -> DataLayout -> Bool
(DataLayout -> DataLayout -> Bool)
-> (DataLayout -> DataLayout -> Bool) -> Eq DataLayout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DataLayout -> DataLayout -> Bool
== :: DataLayout -> DataLayout -> Bool
$c/= :: DataLayout -> DataLayout -> Bool
/= :: DataLayout -> DataLayout -> Bool
Eq, Eq DataLayout
Eq DataLayout
-> (DataLayout -> DataLayout -> Ordering)
-> (DataLayout -> DataLayout -> Bool)
-> (DataLayout -> DataLayout -> Bool)
-> (DataLayout -> DataLayout -> Bool)
-> (DataLayout -> DataLayout -> Bool)
-> (DataLayout -> DataLayout -> DataLayout)
-> (DataLayout -> DataLayout -> DataLayout)
-> Ord DataLayout
DataLayout -> DataLayout -> Bool
DataLayout -> DataLayout -> Ordering
DataLayout -> DataLayout -> DataLayout
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DataLayout -> DataLayout -> Ordering
compare :: DataLayout -> DataLayout -> Ordering
$c< :: DataLayout -> DataLayout -> Bool
< :: DataLayout -> DataLayout -> Bool
$c<= :: DataLayout -> DataLayout -> Bool
<= :: DataLayout -> DataLayout -> Bool
$c> :: DataLayout -> DataLayout -> Bool
> :: DataLayout -> DataLayout -> Bool
$c>= :: DataLayout -> DataLayout -> Bool
>= :: DataLayout -> DataLayout -> Bool
$cmax :: DataLayout -> DataLayout -> DataLayout
max :: DataLayout -> DataLayout -> DataLayout
$cmin :: DataLayout -> DataLayout -> DataLayout
min :: DataLayout -> DataLayout -> DataLayout
Ord, ReadPrec [DataLayout]
ReadPrec DataLayout
Int -> ReadS DataLayout
ReadS [DataLayout]
(Int -> ReadS DataLayout)
-> ReadS [DataLayout]
-> ReadPrec DataLayout
-> ReadPrec [DataLayout]
-> Read DataLayout
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DataLayout
readsPrec :: Int -> ReadS DataLayout
$creadList :: ReadS [DataLayout]
readList :: ReadS [DataLayout]
$creadPrec :: ReadPrec DataLayout
readPrec :: ReadPrec DataLayout
$creadListPrec :: ReadPrec [DataLayout]
readListPrec :: ReadPrec [DataLayout]
Read, Int -> DataLayout -> ShowS
[DataLayout] -> ShowS
DataLayout -> String
(Int -> DataLayout -> ShowS)
-> (DataLayout -> String)
-> ([DataLayout] -> ShowS)
-> Show DataLayout
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DataLayout -> ShowS
showsPrec :: Int -> DataLayout -> ShowS
$cshow :: DataLayout -> String
show :: DataLayout -> String
$cshowList :: [DataLayout] -> ShowS
showList :: [DataLayout] -> ShowS
Show, Typeable, Typeable DataLayout
Typeable DataLayout
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataLayout -> c DataLayout)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataLayout)
-> (DataLayout -> Constr)
-> (DataLayout -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataLayout))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DataLayout))
-> ((forall b. Data b => b -> b) -> DataLayout -> DataLayout)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataLayout -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataLayout -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataLayout -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DataLayout -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataLayout -> m DataLayout)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataLayout -> m DataLayout)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataLayout -> m DataLayout)
-> Data DataLayout
DataLayout -> Constr
DataLayout -> DataType
(forall b. Data b => b -> b) -> DataLayout -> DataLayout
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DataLayout -> u
forall u. (forall d. Data d => d -> u) -> DataLayout -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataLayout -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataLayout -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataLayout -> m DataLayout
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataLayout -> m DataLayout
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataLayout
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataLayout -> c DataLayout
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataLayout)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataLayout)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataLayout -> c DataLayout
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataLayout -> c DataLayout
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataLayout
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataLayout
$ctoConstr :: DataLayout -> Constr
toConstr :: DataLayout -> Constr
$cdataTypeOf :: DataLayout -> DataType
dataTypeOf :: DataLayout -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataLayout)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataLayout)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataLayout)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataLayout)
$cgmapT :: (forall b. Data b => b -> b) -> DataLayout -> DataLayout
gmapT :: (forall b. Data b => b -> b) -> DataLayout -> DataLayout
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataLayout -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataLayout -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataLayout -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataLayout -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataLayout -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataLayout -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataLayout -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataLayout -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataLayout -> m DataLayout
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataLayout -> m DataLayout
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataLayout -> m DataLayout
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataLayout -> m DataLayout
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataLayout -> m DataLayout
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataLayout -> m DataLayout
Data, (forall x. DataLayout -> Rep DataLayout x)
-> (forall x. Rep DataLayout x -> DataLayout) -> Generic DataLayout
forall x. Rep DataLayout x -> DataLayout
forall x. DataLayout -> Rep DataLayout x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DataLayout -> Rep DataLayout x
from :: forall x. DataLayout -> Rep DataLayout x
$cto :: forall x. Rep DataLayout x -> DataLayout
to :: forall x. Rep DataLayout x -> DataLayout
Generic)

-- | a default 'DataLayout'
defaultDataLayout :: Endianness -> DataLayout
defaultDataLayout :: Endianness -> DataLayout
defaultDataLayout Endianness
defaultEndianness = DataLayout {
  endianness :: Endianness
endianness = Endianness
defaultEndianness,
  mangling :: Maybe Mangling
mangling = Maybe Mangling
forall a. Maybe a
Nothing,
  stackAlignment :: Maybe Word32
stackAlignment = Maybe Word32
forall a. Maybe a
Nothing,
  pointerLayouts :: Map AddrSpace (Word32, AlignmentInfo)
pointerLayouts = [(AddrSpace, (Word32, AlignmentInfo))]
-> Map AddrSpace (Word32, AlignmentInfo)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [
    (Word32 -> AddrSpace
AddrSpace Word32
0, (Word32
64, Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
64 Word32
64))
   ],
  typeLayouts :: Map (AlignType, Word32) AlignmentInfo
typeLayouts = [((AlignType, Word32), AlignmentInfo)]
-> Map (AlignType, Word32) AlignmentInfo
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [
    ((AlignType
IntegerAlign, Word32
1), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
8 Word32
8),
    ((AlignType
IntegerAlign, Word32
8), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
8 Word32
8),
    ((AlignType
IntegerAlign, Word32
16), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
16 Word32
16),
    ((AlignType
IntegerAlign, Word32
32), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
32 Word32
32),
    ((AlignType
IntegerAlign, Word32
64), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
32 Word32
64),
    ((AlignType
FloatAlign, Word32
16), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
16 Word32
16),
    ((AlignType
FloatAlign, Word32
32), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
32 Word32
32),
    ((AlignType
FloatAlign, Word32
64), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
64 Word32
64),
    ((AlignType
FloatAlign, Word32
128), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
128 Word32
128),
    ((AlignType
VectorAlign, Word32
64), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
64 Word32
64),
    ((AlignType
VectorAlign, Word32
128), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
128 Word32
128)
   ],
  aggregateLayout :: AlignmentInfo
aggregateLayout = Word32 -> Word32 -> AlignmentInfo
AlignmentInfo Word32
0 Word32
64,
  nativeSizes :: Maybe (Set Word32)
nativeSizes = Maybe (Set Word32)
forall a. Maybe a
Nothing
 }