-- | <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
/= :: Endianness -> Endianness -> Bool
$c/= :: Endianness -> Endianness -> Bool
== :: Endianness -> Endianness -> Bool
$c== :: 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
min :: Endianness -> Endianness -> Endianness
$cmin :: Endianness -> Endianness -> Endianness
max :: Endianness -> Endianness -> Endianness
$cmax :: Endianness -> Endianness -> Endianness
>= :: Endianness -> Endianness -> Bool
$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
compare :: Endianness -> Endianness -> Ordering
$ccompare :: Endianness -> Endianness -> Ordering
$cp1Ord :: Eq 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
readListPrec :: ReadPrec [Endianness]
$creadListPrec :: ReadPrec [Endianness]
readPrec :: ReadPrec Endianness
$creadPrec :: ReadPrec Endianness
readList :: ReadS [Endianness]
$creadList :: ReadS [Endianness]
readsPrec :: Int -> ReadS Endianness
$creadsPrec :: Int -> ReadS 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
showList :: [Endianness] -> ShowS
$cshowList :: [Endianness] -> ShowS
show :: Endianness -> String
$cshow :: Endianness -> String
showsPrec :: Int -> Endianness -> ShowS
$cshowsPrec :: Int -> Endianness -> ShowS
Show, Typeable, Typeable Endianness
DataType
Constr
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 -> DataType
Endianness -> Constr
(forall b. Data b => b -> b) -> Endianness -> Endianness
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Endianness -> c Endianness
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cBigEndian :: Constr
$cLittleEndian :: Constr
$tEndianness :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> Endianness -> m Endianness
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Endianness -> m Endianness
gmapQi :: Int -> (forall d. Data d => d -> u) -> Endianness -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Endianness -> u
gmapQ :: (forall d. Data d => d -> u) -> Endianness -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Endianness -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Endianness -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Endianness -> r
gmapT :: (forall b. Data b => b -> b) -> Endianness -> Endianness
$cgmapT :: (forall b. Data b => b -> b) -> Endianness -> Endianness
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Endianness)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Endianness)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Endianness)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Endianness)
dataTypeOf :: Endianness -> DataType
$cdataTypeOf :: Endianness -> DataType
toConstr :: Endianness -> Constr
$ctoConstr :: Endianness -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Endianness
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Endianness
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Endianness -> c Endianness
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Endianness -> c Endianness
$cp1Data :: Typeable 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
$cto :: forall x. Rep Endianness x -> Endianness
$cfrom :: forall x. Endianness -> Rep Endianness x
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
/= :: AlignmentInfo -> AlignmentInfo -> Bool
$c/= :: AlignmentInfo -> AlignmentInfo -> Bool
== :: AlignmentInfo -> AlignmentInfo -> Bool
$c== :: 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
min :: AlignmentInfo -> AlignmentInfo -> AlignmentInfo
$cmin :: AlignmentInfo -> AlignmentInfo -> AlignmentInfo
max :: AlignmentInfo -> AlignmentInfo -> AlignmentInfo
$cmax :: AlignmentInfo -> AlignmentInfo -> AlignmentInfo
>= :: AlignmentInfo -> AlignmentInfo -> Bool
$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
compare :: AlignmentInfo -> AlignmentInfo -> Ordering
$ccompare :: AlignmentInfo -> AlignmentInfo -> Ordering
$cp1Ord :: Eq 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
readListPrec :: ReadPrec [AlignmentInfo]
$creadListPrec :: ReadPrec [AlignmentInfo]
readPrec :: ReadPrec AlignmentInfo
$creadPrec :: ReadPrec AlignmentInfo
readList :: ReadS [AlignmentInfo]
$creadList :: ReadS [AlignmentInfo]
readsPrec :: Int -> ReadS AlignmentInfo
$creadsPrec :: Int -> ReadS 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
showList :: [AlignmentInfo] -> ShowS
$cshowList :: [AlignmentInfo] -> ShowS
show :: AlignmentInfo -> String
$cshow :: AlignmentInfo -> String
showsPrec :: Int -> AlignmentInfo -> ShowS
$cshowsPrec :: Int -> AlignmentInfo -> ShowS
Show, Typeable, Typeable AlignmentInfo
DataType
Constr
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 -> DataType
AlignmentInfo -> Constr
(forall b. Data b => b -> b) -> AlignmentInfo -> AlignmentInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignmentInfo -> c AlignmentInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cAlignmentInfo :: Constr
$tAlignmentInfo :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AlignmentInfo -> m AlignmentInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> AlignmentInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AlignmentInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> AlignmentInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AlignmentInfo -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlignmentInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlignmentInfo -> r
gmapT :: (forall b. Data b => b -> b) -> AlignmentInfo -> AlignmentInfo
$cgmapT :: (forall b. Data b => b -> b) -> AlignmentInfo -> AlignmentInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlignmentInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlignmentInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c AlignmentInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlignmentInfo)
dataTypeOf :: AlignmentInfo -> DataType
$cdataTypeOf :: AlignmentInfo -> DataType
toConstr :: AlignmentInfo -> Constr
$ctoConstr :: AlignmentInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlignmentInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlignmentInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignmentInfo -> c AlignmentInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignmentInfo -> c AlignmentInfo
$cp1Data :: Typeable 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
$cto :: forall x. Rep AlignmentInfo x -> AlignmentInfo
$cfrom :: forall x. AlignmentInfo -> Rep AlignmentInfo x
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
/= :: AlignType -> AlignType -> Bool
$c/= :: AlignType -> AlignType -> Bool
== :: AlignType -> AlignType -> Bool
$c== :: 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
min :: AlignType -> AlignType -> AlignType
$cmin :: AlignType -> AlignType -> AlignType
max :: AlignType -> AlignType -> AlignType
$cmax :: AlignType -> AlignType -> AlignType
>= :: AlignType -> AlignType -> Bool
$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
compare :: AlignType -> AlignType -> Ordering
$ccompare :: AlignType -> AlignType -> Ordering
$cp1Ord :: Eq 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
readListPrec :: ReadPrec [AlignType]
$creadListPrec :: ReadPrec [AlignType]
readPrec :: ReadPrec AlignType
$creadPrec :: ReadPrec AlignType
readList :: ReadS [AlignType]
$creadList :: ReadS [AlignType]
readsPrec :: Int -> ReadS AlignType
$creadsPrec :: Int -> ReadS 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
showList :: [AlignType] -> ShowS
$cshowList :: [AlignType] -> ShowS
show :: AlignType -> String
$cshow :: AlignType -> String
showsPrec :: Int -> AlignType -> ShowS
$cshowsPrec :: Int -> AlignType -> ShowS
Show, Typeable, Typeable AlignType
DataType
Constr
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 -> DataType
AlignType -> Constr
(forall b. Data b => b -> b) -> AlignType -> AlignType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignType -> c AlignType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cFloatAlign :: Constr
$cVectorAlign :: Constr
$cIntegerAlign :: Constr
$tAlignType :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> AlignType -> m AlignType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AlignType -> m AlignType
gmapQi :: Int -> (forall d. Data d => d -> u) -> AlignType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AlignType -> u
gmapQ :: (forall d. Data d => d -> u) -> AlignType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AlignType -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlignType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlignType -> r
gmapT :: (forall b. Data b => b -> b) -> AlignType -> AlignType
$cgmapT :: (forall b. Data b => b -> b) -> AlignType -> AlignType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlignType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlignType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c AlignType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlignType)
dataTypeOf :: AlignType -> DataType
$cdataTypeOf :: AlignType -> DataType
toConstr :: AlignType -> Constr
$ctoConstr :: AlignType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlignType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlignType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignType -> c AlignType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlignType -> c AlignType
$cp1Data :: Typeable 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
$cto :: forall x. Rep AlignType x -> AlignType
$cfrom :: forall x. AlignType -> Rep AlignType x
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
/= :: Mangling -> Mangling -> Bool
$c/= :: Mangling -> Mangling -> Bool
== :: Mangling -> Mangling -> Bool
$c== :: 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
min :: Mangling -> Mangling -> Mangling
$cmin :: Mangling -> Mangling -> Mangling
max :: Mangling -> Mangling -> Mangling
$cmax :: Mangling -> Mangling -> Mangling
>= :: Mangling -> Mangling -> Bool
$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
compare :: Mangling -> Mangling -> Ordering
$ccompare :: Mangling -> Mangling -> Ordering
$cp1Ord :: Eq 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
readListPrec :: ReadPrec [Mangling]
$creadListPrec :: ReadPrec [Mangling]
readPrec :: ReadPrec Mangling
$creadPrec :: ReadPrec Mangling
readList :: ReadS [Mangling]
$creadList :: ReadS [Mangling]
readsPrec :: Int -> ReadS Mangling
$creadsPrec :: Int -> ReadS 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
showList :: [Mangling] -> ShowS
$cshowList :: [Mangling] -> ShowS
show :: Mangling -> String
$cshow :: Mangling -> String
showsPrec :: Int -> Mangling -> ShowS
$cshowsPrec :: Int -> Mangling -> ShowS
Show, Typeable, Typeable Mangling
DataType
Constr
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 -> DataType
Mangling -> Constr
(forall b. Data b => b -> b) -> Mangling -> Mangling
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mangling -> c Mangling
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cWindowsCOFFMangling :: Constr
$cMachOMangling :: Constr
$cMIPSMangling :: Constr
$cELFMangling :: Constr
$tMangling :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> Mangling -> m Mangling
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mangling -> m Mangling
gmapQi :: Int -> (forall d. Data d => d -> u) -> Mangling -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Mangling -> u
gmapQ :: (forall d. Data d => d -> u) -> Mangling -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Mangling -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Mangling -> r
gmapT :: (forall b. Data b => b -> b) -> Mangling -> Mangling
$cgmapT :: (forall b. Data b => b -> b) -> Mangling -> Mangling
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mangling)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mangling)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Mangling)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mangling)
dataTypeOf :: Mangling -> DataType
$cdataTypeOf :: Mangling -> DataType
toConstr :: Mangling -> Constr
$ctoConstr :: Mangling -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mangling
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mangling
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mangling -> c Mangling
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mangling -> c Mangling
$cp1Data :: Typeable 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
$cto :: forall x. Rep Mangling x -> Mangling
$cfrom :: forall x. Mangling -> Rep Mangling x
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
/= :: DataLayout -> DataLayout -> Bool
$c/= :: DataLayout -> DataLayout -> Bool
== :: DataLayout -> DataLayout -> Bool
$c== :: 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
min :: DataLayout -> DataLayout -> DataLayout
$cmin :: DataLayout -> DataLayout -> DataLayout
max :: DataLayout -> DataLayout -> DataLayout
$cmax :: DataLayout -> DataLayout -> DataLayout
>= :: DataLayout -> DataLayout -> Bool
$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
compare :: DataLayout -> DataLayout -> Ordering
$ccompare :: DataLayout -> DataLayout -> Ordering
$cp1Ord :: Eq 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
readListPrec :: ReadPrec [DataLayout]
$creadListPrec :: ReadPrec [DataLayout]
readPrec :: ReadPrec DataLayout
$creadPrec :: ReadPrec DataLayout
readList :: ReadS [DataLayout]
$creadList :: ReadS [DataLayout]
readsPrec :: Int -> ReadS DataLayout
$creadsPrec :: Int -> ReadS 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
showList :: [DataLayout] -> ShowS
$cshowList :: [DataLayout] -> ShowS
show :: DataLayout -> String
$cshow :: DataLayout -> String
showsPrec :: Int -> DataLayout -> ShowS
$cshowsPrec :: Int -> DataLayout -> ShowS
Show, Typeable, Typeable DataLayout
DataType
Constr
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 -> DataType
DataLayout -> Constr
(forall b. Data b => b -> b) -> DataLayout -> DataLayout
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataLayout -> c DataLayout
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDataLayout :: Constr
$tDataLayout :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> DataLayout -> m DataLayout
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataLayout -> m DataLayout
gmapQi :: Int -> (forall d. Data d => d -> u) -> DataLayout -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataLayout -> u
gmapQ :: (forall d. Data d => d -> u) -> DataLayout -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataLayout -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataLayout -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataLayout -> r
gmapT :: (forall b. Data b => b -> b) -> DataLayout -> DataLayout
$cgmapT :: (forall b. Data b => b -> b) -> DataLayout -> DataLayout
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataLayout)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataLayout)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DataLayout)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataLayout)
dataTypeOf :: DataLayout -> DataType
$cdataTypeOf :: DataLayout -> DataType
toConstr :: DataLayout -> Constr
$ctoConstr :: DataLayout -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataLayout
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataLayout
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataLayout -> c DataLayout
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataLayout -> c DataLayout
$cp1Data :: Typeable 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
$cto :: forall x. Rep DataLayout x -> DataLayout
$cfrom :: forall x. DataLayout -> Rep DataLayout x
Generic)

-- | a default 'DataLayout'
defaultDataLayout :: Endianness -> DataLayout
defaultDataLayout :: Endianness -> DataLayout
defaultDataLayout defaultEndianness :: Endianness
defaultEndianness = DataLayout :: Endianness
-> Maybe Mangling
-> Maybe Word32
-> Map AddrSpace (Word32, AlignmentInfo)
-> Map (AlignType, Word32) AlignmentInfo
-> AlignmentInfo
-> Maybe (Set Word32)
-> DataLayout
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 0, (64, Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 64 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, 1), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 8 8),
    ((AlignType
IntegerAlign, 8), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 8 8),
    ((AlignType
IntegerAlign, 16), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 16 16),
    ((AlignType
IntegerAlign, 32), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 32 32),
    ((AlignType
IntegerAlign, 64), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 32 64),
    ((AlignType
FloatAlign, 16), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 16 16),
    ((AlignType
FloatAlign, 32), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 32 32),
    ((AlignType
FloatAlign, 64), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 64 64),
    ((AlignType
FloatAlign, 128), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 128 128),
    ((AlignType
VectorAlign, 64), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 64 64),
    ((AlignType
VectorAlign, 128), Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 128 128)
   ],
  aggregateLayout :: AlignmentInfo
aggregateLayout = Word32 -> Word32 -> AlignmentInfo
AlignmentInfo 0 64,
  nativeSizes :: Maybe (Set Word32)
nativeSizes = Maybe (Set Word32)
forall a. Maybe a
Nothing
 }