{- |
Module      : Text.LLVM.Triple.AST
Description : AST of LLVM target triples.
License     : BSD3
Maintainer  : Langston Barrett
Stability   : experimental
-}

{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE StrictData #-}

module Text.LLVM.Triple.AST
  ( Arch(..)
  , SubArch(..)
  , Vendor(..)
  , OS(..)
  , Environment(..)
  , ObjectFormat(..)
  , TargetTriple(..)
  ) where

import Data.Data (Data)
import Data.Typeable (Typeable)
import GHC.Generics (Generic)

-- | The constructors of this type exactly mirror the LLVM @enum ArchType@,
-- including inconsistent labeling of endianness. Capitalization is taken from
-- the LLVM comments, which are reproduced below.
--
-- Last updated: LLVM 15.0.1:
-- https://github.com/llvm/llvm-project/blob/llvmorg-15.0.1/llvm/include/llvm/ADT/Triple.h#L46
data Arch
  = UnknownArch
    -- | ARM (little endian): arm armv.* xscale
  | ARM
    -- | ARM (big endian): armeb
  | ARMEB
    -- | AArch64 (little endian): aarch64
  | AArch64
    -- | AArch64 (big endian): aarch64_be
  | AArch64_BE
    -- | AArch64 (little endian) ILP32: aarch64_32
  | AArch64_32
    -- | ARC: Synopsys ARC
  | ARC
    -- | AVR: Atmel AVR microcontroller
  | AVR
    -- | eBPF or extended BPF or 64-bit BPF (little endian)
  | BPFEL
    -- | eBPF or extended BPF or 64-bit BPF (big endian)
  | BPFEB
    -- | CSKY: csky
  | CSKY
    -- | DXIL 32-bit DirectX bytecode
  | DXIL
    -- | Hexagon: hexagon
  | Hexagon
    -- | LoongArch (32-bit): loongarch32
  | LoongArch32
    -- | LoongArch (64-bit): loongarch64
  | LoongArch64
    -- | M68k: Motorola 680x0 family
  | M68k
    -- | MIPS: mips mipsallegrex mipsr6
  | MIPS
    -- | MIPSEL: mipsel mipsallegrexe mipsr6el
  | MIPSEL
    -- | MIPS64: mips64 mips64r6 mipsn32 mipsn32r6
  | MIPS64
    -- | MIPS64EL: mips64el mips64r6el mipsn32el mipsn32r6el
  | MIPS64EL
    -- | MSP430: msp430
  | MSP430
    -- | PPC: powerpc
  | PPC
    -- | PPCLE: powerpc (little endian)
  | PPCLE
    -- | PPC64: powerpc64 ppu
  | PPC64
    -- | PPC64LE: powerpc64le
  | PPC64LE
    -- | R600: AMD GPUs HD2XXX - HD6XXX
  | R600
    -- | AMDGCN: AMD GCN GPUs
  | AMDGCN
    -- | RISC-V (32-bit): riscv32
  | RISCV32
    -- | RISC-V (64-bit): riscv64
  | RISCV64
    -- | Sparc: sparc
  | Sparc
    -- | Sparcv9: Sparcv9
  | Sparcv9
    -- | Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant
  | SparcEL
    -- | SystemZ: s390x
  | SystemZ
    -- | TCE (http://tce.cs.tut.fi/): tce
  | TCE
    -- | TCE little endian (http://tce.cs.tut.fi/): tcele
  | TCELE
    -- | Thumb (little endian): thumb thumbv.*
  | Thumb
    -- | Thumb (big endian): thumbeb
  | ThumbEB
    -- | X86: i[3-9]86
  | X86
    -- | X86-64: amd64 x86_64
  | X86_64
    -- | XCore: xcore
  | XCore
    -- | NVPTX: 32-bit
  | NVPTX
    -- | NVPTX: 64-bit
  | NVPTX64
    -- | le32: generic little-endian 32-bit CPU (PNaCl)
  | Le32
    -- | le64: generic little-endian 64-bit CPU (PNaCl)
  | Le64
    -- | AMDIL
  | AMDIL
    -- | AMDIL with 64-bit pointers
  | AMDIL64
    -- | AMD HSAIL
  | HSAIL
    -- | AMD HSAIL with 64-bit pointers
  | HSAIL64
    -- | SPIR: standard portable IR for OpenCL 32-bit version
  | SPIR
    -- | SPIR: standard portable IR for OpenCL 64-bit version
  | SPIR64
    -- | SPIR-V with 32-bit pointers
  | SPIRV32
    -- | SPIR-V with 64-bit pointers
  | SPIRV64
    -- | Kalimba: generic kalimba
  | Kalimba
    -- | SHAVE: Movidius vector VLIW processors
  | SHAVE
    -- | Lanai: Lanai 32-bit
  | Lanai
    -- | WebAssembly with 32-bit pointers
  | Wasm32
    -- | WebAssembly with 64-bit pointers
  | Wasm64
    -- | 32-bit RenderScript
  | RenderScript32 -- 32-bit RenderScript
    -- | 64-bit RenderScript
  | RenderScript64
    -- | NEC SX-Aurora Vector Engine
  | VE
  deriving (Arch
Arch -> Arch -> Bounded Arch
forall a. a -> a -> Bounded a
$cminBound :: Arch
minBound :: Arch
$cmaxBound :: Arch
maxBound :: Arch
Bounded, Typeable Arch
Typeable Arch =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Arch -> c Arch)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Arch)
-> (Arch -> Constr)
-> (Arch -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Arch))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Arch))
-> ((forall b. Data b => b -> b) -> Arch -> Arch)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arch -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arch -> r)
-> (forall u. (forall d. Data d => d -> u) -> Arch -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Arch -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Arch -> m Arch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Arch -> m Arch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Arch -> m Arch)
-> Data Arch
Arch -> Constr
Arch -> DataType
(forall b. Data b => b -> b) -> Arch -> Arch
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) -> Arch -> u
forall u. (forall d. Data d => d -> u) -> Arch -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arch -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arch -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Arch -> m Arch
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Arch -> m Arch
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Arch
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Arch -> c Arch
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Arch)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Arch)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Arch -> c Arch
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Arch -> c Arch
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Arch
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Arch
$ctoConstr :: Arch -> Constr
toConstr :: Arch -> Constr
$cdataTypeOf :: Arch -> DataType
dataTypeOf :: Arch -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Arch)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Arch)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Arch)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Arch)
$cgmapT :: (forall b. Data b => b -> b) -> Arch -> Arch
gmapT :: (forall b. Data b => b -> b) -> Arch -> Arch
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arch -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arch -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arch -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arch -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Arch -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Arch -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Arch -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Arch -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Arch -> m Arch
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Arch -> m Arch
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Arch -> m Arch
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Arch -> m Arch
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Arch -> m Arch
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Arch -> m Arch
Data, Arch -> Arch -> Bool
(Arch -> Arch -> Bool) -> (Arch -> Arch -> Bool) -> Eq Arch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Arch -> Arch -> Bool
== :: Arch -> Arch -> Bool
$c/= :: Arch -> Arch -> Bool
/= :: Arch -> Arch -> Bool
Eq, Int -> Arch
Arch -> Int
Arch -> [Arch]
Arch -> Arch
Arch -> Arch -> [Arch]
Arch -> Arch -> Arch -> [Arch]
(Arch -> Arch)
-> (Arch -> Arch)
-> (Int -> Arch)
-> (Arch -> Int)
-> (Arch -> [Arch])
-> (Arch -> Arch -> [Arch])
-> (Arch -> Arch -> [Arch])
-> (Arch -> Arch -> Arch -> [Arch])
-> Enum Arch
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Arch -> Arch
succ :: Arch -> Arch
$cpred :: Arch -> Arch
pred :: Arch -> Arch
$ctoEnum :: Int -> Arch
toEnum :: Int -> Arch
$cfromEnum :: Arch -> Int
fromEnum :: Arch -> Int
$cenumFrom :: Arch -> [Arch]
enumFrom :: Arch -> [Arch]
$cenumFromThen :: Arch -> Arch -> [Arch]
enumFromThen :: Arch -> Arch -> [Arch]
$cenumFromTo :: Arch -> Arch -> [Arch]
enumFromTo :: Arch -> Arch -> [Arch]
$cenumFromThenTo :: Arch -> Arch -> Arch -> [Arch]
enumFromThenTo :: Arch -> Arch -> Arch -> [Arch]
Enum, (forall x. Arch -> Rep Arch x)
-> (forall x. Rep Arch x -> Arch) -> Generic Arch
forall x. Rep Arch x -> Arch
forall x. Arch -> Rep Arch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Arch -> Rep Arch x
from :: forall x. Arch -> Rep Arch x
$cto :: forall x. Rep Arch x -> Arch
to :: forall x. Rep Arch x -> Arch
Generic, Eq Arch
Eq Arch =>
(Arch -> Arch -> Ordering)
-> (Arch -> Arch -> Bool)
-> (Arch -> Arch -> Bool)
-> (Arch -> Arch -> Bool)
-> (Arch -> Arch -> Bool)
-> (Arch -> Arch -> Arch)
-> (Arch -> Arch -> Arch)
-> Ord Arch
Arch -> Arch -> Bool
Arch -> Arch -> Ordering
Arch -> Arch -> Arch
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 :: Arch -> Arch -> Ordering
compare :: Arch -> Arch -> Ordering
$c< :: Arch -> Arch -> Bool
< :: Arch -> Arch -> Bool
$c<= :: Arch -> Arch -> Bool
<= :: Arch -> Arch -> Bool
$c> :: Arch -> Arch -> Bool
> :: Arch -> Arch -> Bool
$c>= :: Arch -> Arch -> Bool
>= :: Arch -> Arch -> Bool
$cmax :: Arch -> Arch -> Arch
max :: Arch -> Arch -> Arch
$cmin :: Arch -> Arch -> Arch
min :: Arch -> Arch -> Arch
Ord, ReadPrec [Arch]
ReadPrec Arch
Int -> ReadS Arch
ReadS [Arch]
(Int -> ReadS Arch)
-> ReadS [Arch] -> ReadPrec Arch -> ReadPrec [Arch] -> Read Arch
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Arch
readsPrec :: Int -> ReadS Arch
$creadList :: ReadS [Arch]
readList :: ReadS [Arch]
$creadPrec :: ReadPrec Arch
readPrec :: ReadPrec Arch
$creadListPrec :: ReadPrec [Arch]
readListPrec :: ReadPrec [Arch]
Read, Int -> Arch -> ShowS
[Arch] -> ShowS
Arch -> String
(Int -> Arch -> ShowS)
-> (Arch -> String) -> ([Arch] -> ShowS) -> Show Arch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Arch -> ShowS
showsPrec :: Int -> Arch -> ShowS
$cshow :: Arch -> String
show :: Arch -> String
$cshowList :: [Arch] -> ShowS
showList :: [Arch] -> ShowS
Show, Typeable)

-- | A 'First'-like semigroup instance that simply drops the RHS, unless the LHS
-- is 'UnknownArch'.
instance Semigroup Arch where
  Arch
a <> :: Arch -> Arch -> Arch
<> UnknownArch{} = Arch
a
  UnknownArch{} <> Arch
b = Arch
b
  Arch
a <> Arch
_ = Arch
a

-- | @'mempty' == 'UnknownArch'@
instance Monoid Arch where
  mempty :: Arch
mempty = Arch
UnknownArch

-- | The constructors of this type exactly mirror the LLVM @enum SubArchType@.
--
-- Last updated: LLVM 15.0.1:
-- https://github.com/llvm/llvm-project/blob/llvmorg-15.0.1/llvm/include/llvm/ADT/Triple.h#L110
data SubArch
  = NoSubArch
  | ARMSubArch_v9_3a
  | ARMSubArch_v9_2a
  | ARMSubArch_v9_1a
  | ARMSubArch_v9
  | ARMSubArch_v8_8a
  | ARMSubArch_v8_7a
  | ARMSubArch_v8_6a
  | ARMSubArch_v8_5a
  | ARMSubArch_v8_4a
  | ARMSubArch_v8_3a
  | ARMSubArch_v8_2a
  | ARMSubArch_v8_1a
  | ARMSubArch_v8
  | ARMSubArch_v8r
  | ARMSubArch_v8m_baseline
  | ARMSubArch_v8m_mainline
  | ARMSubArch_v8_1m_mainline
  | ARMSubArch_v7
  | ARMSubArch_v7em
  | ARMSubArch_v7m
  | ARMSubArch_v7s
  | ARMSubArch_v7k
  | ARMSubArch_v7ve
  | ARMSubArch_v6
  | ARMSubArch_v6m
  | ARMSubArch_v6k
  | ARMSubArch_v6t2
  | ARMSubArch_v5
  | ARMSubArch_v5te
  | ARMSubArch_v4t

  | AArch64SubArch_arm64e

  | KalimbaSubArch_v3
  | KalimbaSubArch_v4
  | KalimbaSubArch_v5

  | MipsSubArch_r6

  | PPCSubArch_spe

  | SPIRVSubArch_v10
  | SPIRVSubArch_v11
  | SPIRVSubArch_v12
  | SPIRVSubArch_v13
  | SPIRVSubArch_v14
  | SPIRVSubArch_v15
  deriving (SubArch
SubArch -> SubArch -> Bounded SubArch
forall a. a -> a -> Bounded a
$cminBound :: SubArch
minBound :: SubArch
$cmaxBound :: SubArch
maxBound :: SubArch
Bounded, Typeable SubArch
Typeable SubArch =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SubArch -> c SubArch)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SubArch)
-> (SubArch -> Constr)
-> (SubArch -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SubArch))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubArch))
-> ((forall b. Data b => b -> b) -> SubArch -> SubArch)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SubArch -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SubArch -> r)
-> (forall u. (forall d. Data d => d -> u) -> SubArch -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SubArch -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SubArch -> m SubArch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SubArch -> m SubArch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SubArch -> m SubArch)
-> Data SubArch
SubArch -> Constr
SubArch -> DataType
(forall b. Data b => b -> b) -> SubArch -> SubArch
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) -> SubArch -> u
forall u. (forall d. Data d => d -> u) -> SubArch -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubArch -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubArch -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SubArch -> m SubArch
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubArch -> m SubArch
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubArch
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubArch -> c SubArch
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubArch)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubArch)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubArch -> c SubArch
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubArch -> c SubArch
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubArch
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubArch
$ctoConstr :: SubArch -> Constr
toConstr :: SubArch -> Constr
$cdataTypeOf :: SubArch -> DataType
dataTypeOf :: SubArch -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubArch)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubArch)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubArch)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubArch)
$cgmapT :: (forall b. Data b => b -> b) -> SubArch -> SubArch
gmapT :: (forall b. Data b => b -> b) -> SubArch -> SubArch
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubArch -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubArch -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubArch -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubArch -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SubArch -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SubArch -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SubArch -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SubArch -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SubArch -> m SubArch
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SubArch -> m SubArch
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubArch -> m SubArch
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubArch -> m SubArch
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubArch -> m SubArch
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubArch -> m SubArch
Data, Int -> SubArch
SubArch -> Int
SubArch -> [SubArch]
SubArch -> SubArch
SubArch -> SubArch -> [SubArch]
SubArch -> SubArch -> SubArch -> [SubArch]
(SubArch -> SubArch)
-> (SubArch -> SubArch)
-> (Int -> SubArch)
-> (SubArch -> Int)
-> (SubArch -> [SubArch])
-> (SubArch -> SubArch -> [SubArch])
-> (SubArch -> SubArch -> [SubArch])
-> (SubArch -> SubArch -> SubArch -> [SubArch])
-> Enum SubArch
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SubArch -> SubArch
succ :: SubArch -> SubArch
$cpred :: SubArch -> SubArch
pred :: SubArch -> SubArch
$ctoEnum :: Int -> SubArch
toEnum :: Int -> SubArch
$cfromEnum :: SubArch -> Int
fromEnum :: SubArch -> Int
$cenumFrom :: SubArch -> [SubArch]
enumFrom :: SubArch -> [SubArch]
$cenumFromThen :: SubArch -> SubArch -> [SubArch]
enumFromThen :: SubArch -> SubArch -> [SubArch]
$cenumFromTo :: SubArch -> SubArch -> [SubArch]
enumFromTo :: SubArch -> SubArch -> [SubArch]
$cenumFromThenTo :: SubArch -> SubArch -> SubArch -> [SubArch]
enumFromThenTo :: SubArch -> SubArch -> SubArch -> [SubArch]
Enum, SubArch -> SubArch -> Bool
(SubArch -> SubArch -> Bool)
-> (SubArch -> SubArch -> Bool) -> Eq SubArch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubArch -> SubArch -> Bool
== :: SubArch -> SubArch -> Bool
$c/= :: SubArch -> SubArch -> Bool
/= :: SubArch -> SubArch -> Bool
Eq, (forall x. SubArch -> Rep SubArch x)
-> (forall x. Rep SubArch x -> SubArch) -> Generic SubArch
forall x. Rep SubArch x -> SubArch
forall x. SubArch -> Rep SubArch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SubArch -> Rep SubArch x
from :: forall x. SubArch -> Rep SubArch x
$cto :: forall x. Rep SubArch x -> SubArch
to :: forall x. Rep SubArch x -> SubArch
Generic, Eq SubArch
Eq SubArch =>
(SubArch -> SubArch -> Ordering)
-> (SubArch -> SubArch -> Bool)
-> (SubArch -> SubArch -> Bool)
-> (SubArch -> SubArch -> Bool)
-> (SubArch -> SubArch -> Bool)
-> (SubArch -> SubArch -> SubArch)
-> (SubArch -> SubArch -> SubArch)
-> Ord SubArch
SubArch -> SubArch -> Bool
SubArch -> SubArch -> Ordering
SubArch -> SubArch -> SubArch
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 :: SubArch -> SubArch -> Ordering
compare :: SubArch -> SubArch -> Ordering
$c< :: SubArch -> SubArch -> Bool
< :: SubArch -> SubArch -> Bool
$c<= :: SubArch -> SubArch -> Bool
<= :: SubArch -> SubArch -> Bool
$c> :: SubArch -> SubArch -> Bool
> :: SubArch -> SubArch -> Bool
$c>= :: SubArch -> SubArch -> Bool
>= :: SubArch -> SubArch -> Bool
$cmax :: SubArch -> SubArch -> SubArch
max :: SubArch -> SubArch -> SubArch
$cmin :: SubArch -> SubArch -> SubArch
min :: SubArch -> SubArch -> SubArch
Ord, ReadPrec [SubArch]
ReadPrec SubArch
Int -> ReadS SubArch
ReadS [SubArch]
(Int -> ReadS SubArch)
-> ReadS [SubArch]
-> ReadPrec SubArch
-> ReadPrec [SubArch]
-> Read SubArch
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SubArch
readsPrec :: Int -> ReadS SubArch
$creadList :: ReadS [SubArch]
readList :: ReadS [SubArch]
$creadPrec :: ReadPrec SubArch
readPrec :: ReadPrec SubArch
$creadListPrec :: ReadPrec [SubArch]
readListPrec :: ReadPrec [SubArch]
Read, Int -> SubArch -> ShowS
[SubArch] -> ShowS
SubArch -> String
(Int -> SubArch -> ShowS)
-> (SubArch -> String) -> ([SubArch] -> ShowS) -> Show SubArch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubArch -> ShowS
showsPrec :: Int -> SubArch -> ShowS
$cshow :: SubArch -> String
show :: SubArch -> String
$cshowList :: [SubArch] -> ShowS
showList :: [SubArch] -> ShowS
Show, Typeable)

-- | A 'First'-like semigroup instance that simply drops the RHS, unless the LHS
-- is 'NoSubArch'.
instance Semigroup SubArch where
  SubArch
a <> :: SubArch -> SubArch -> SubArch
<> NoSubArch{} = SubArch
a
  NoSubArch{} <> SubArch
b = SubArch
b
  SubArch
a <> SubArch
_ = SubArch
a

-- | @'mempty' == 'NoSubArch'@
instance Monoid SubArch where
  mempty :: SubArch
mempty = SubArch
NoSubArch

-- | The constructors of this type exactly mirror the LLVM @enum VendorType@,
-- including ordering and grouping.
--
-- Last updated: LLVM 15.0.1:
-- https://github.com/llvm/llvm-project/blob/llvmorg-15.0.1/llvm/include/llvm/ADT/Triple.h#L162
data Vendor
  = UnknownVendor
  | Apple
  | PC
  | SCEI
  | Freescale
  | IBM
  | ImaginationTechnologies
  | MipsTechnologies
  | NVIDIA
  | CSR
  | Myriad
  | AMD
  | Mesa
  | SUSE
  | OpenEmbedded
  deriving (Vendor
Vendor -> Vendor -> Bounded Vendor
forall a. a -> a -> Bounded a
$cminBound :: Vendor
minBound :: Vendor
$cmaxBound :: Vendor
maxBound :: Vendor
Bounded, Typeable Vendor
Typeable Vendor =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Vendor -> c Vendor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Vendor)
-> (Vendor -> Constr)
-> (Vendor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Vendor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vendor))
-> ((forall b. Data b => b -> b) -> Vendor -> Vendor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Vendor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Vendor -> r)
-> (forall u. (forall d. Data d => d -> u) -> Vendor -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Vendor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Vendor -> m Vendor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Vendor -> m Vendor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Vendor -> m Vendor)
-> Data Vendor
Vendor -> Constr
Vendor -> DataType
(forall b. Data b => b -> b) -> Vendor -> Vendor
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) -> Vendor -> u
forall u. (forall d. Data d => d -> u) -> Vendor -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vendor -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vendor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Vendor -> m Vendor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Vendor -> m Vendor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vendor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vendor -> c Vendor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Vendor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vendor)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vendor -> c Vendor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vendor -> c Vendor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vendor
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Vendor
$ctoConstr :: Vendor -> Constr
toConstr :: Vendor -> Constr
$cdataTypeOf :: Vendor -> DataType
dataTypeOf :: Vendor -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Vendor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Vendor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vendor)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Vendor)
$cgmapT :: (forall b. Data b => b -> b) -> Vendor -> Vendor
gmapT :: (forall b. Data b => b -> b) -> Vendor -> Vendor
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vendor -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vendor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vendor -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vendor -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Vendor -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Vendor -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Vendor -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Vendor -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Vendor -> m Vendor
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Vendor -> m Vendor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Vendor -> m Vendor
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Vendor -> m Vendor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Vendor -> m Vendor
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Vendor -> m Vendor
Data, Int -> Vendor
Vendor -> Int
Vendor -> [Vendor]
Vendor -> Vendor
Vendor -> Vendor -> [Vendor]
Vendor -> Vendor -> Vendor -> [Vendor]
(Vendor -> Vendor)
-> (Vendor -> Vendor)
-> (Int -> Vendor)
-> (Vendor -> Int)
-> (Vendor -> [Vendor])
-> (Vendor -> Vendor -> [Vendor])
-> (Vendor -> Vendor -> [Vendor])
-> (Vendor -> Vendor -> Vendor -> [Vendor])
-> Enum Vendor
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Vendor -> Vendor
succ :: Vendor -> Vendor
$cpred :: Vendor -> Vendor
pred :: Vendor -> Vendor
$ctoEnum :: Int -> Vendor
toEnum :: Int -> Vendor
$cfromEnum :: Vendor -> Int
fromEnum :: Vendor -> Int
$cenumFrom :: Vendor -> [Vendor]
enumFrom :: Vendor -> [Vendor]
$cenumFromThen :: Vendor -> Vendor -> [Vendor]
enumFromThen :: Vendor -> Vendor -> [Vendor]
$cenumFromTo :: Vendor -> Vendor -> [Vendor]
enumFromTo :: Vendor -> Vendor -> [Vendor]
$cenumFromThenTo :: Vendor -> Vendor -> Vendor -> [Vendor]
enumFromThenTo :: Vendor -> Vendor -> Vendor -> [Vendor]
Enum, Vendor -> Vendor -> Bool
(Vendor -> Vendor -> Bool)
-> (Vendor -> Vendor -> Bool) -> Eq Vendor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Vendor -> Vendor -> Bool
== :: Vendor -> Vendor -> Bool
$c/= :: Vendor -> Vendor -> Bool
/= :: Vendor -> Vendor -> Bool
Eq, (forall x. Vendor -> Rep Vendor x)
-> (forall x. Rep Vendor x -> Vendor) -> Generic Vendor
forall x. Rep Vendor x -> Vendor
forall x. Vendor -> Rep Vendor x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Vendor -> Rep Vendor x
from :: forall x. Vendor -> Rep Vendor x
$cto :: forall x. Rep Vendor x -> Vendor
to :: forall x. Rep Vendor x -> Vendor
Generic, Eq Vendor
Eq Vendor =>
(Vendor -> Vendor -> Ordering)
-> (Vendor -> Vendor -> Bool)
-> (Vendor -> Vendor -> Bool)
-> (Vendor -> Vendor -> Bool)
-> (Vendor -> Vendor -> Bool)
-> (Vendor -> Vendor -> Vendor)
-> (Vendor -> Vendor -> Vendor)
-> Ord Vendor
Vendor -> Vendor -> Bool
Vendor -> Vendor -> Ordering
Vendor -> Vendor -> Vendor
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 :: Vendor -> Vendor -> Ordering
compare :: Vendor -> Vendor -> Ordering
$c< :: Vendor -> Vendor -> Bool
< :: Vendor -> Vendor -> Bool
$c<= :: Vendor -> Vendor -> Bool
<= :: Vendor -> Vendor -> Bool
$c> :: Vendor -> Vendor -> Bool
> :: Vendor -> Vendor -> Bool
$c>= :: Vendor -> Vendor -> Bool
>= :: Vendor -> Vendor -> Bool
$cmax :: Vendor -> Vendor -> Vendor
max :: Vendor -> Vendor -> Vendor
$cmin :: Vendor -> Vendor -> Vendor
min :: Vendor -> Vendor -> Vendor
Ord, ReadPrec [Vendor]
ReadPrec Vendor
Int -> ReadS Vendor
ReadS [Vendor]
(Int -> ReadS Vendor)
-> ReadS [Vendor]
-> ReadPrec Vendor
-> ReadPrec [Vendor]
-> Read Vendor
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Vendor
readsPrec :: Int -> ReadS Vendor
$creadList :: ReadS [Vendor]
readList :: ReadS [Vendor]
$creadPrec :: ReadPrec Vendor
readPrec :: ReadPrec Vendor
$creadListPrec :: ReadPrec [Vendor]
readListPrec :: ReadPrec [Vendor]
Read, Int -> Vendor -> ShowS
[Vendor] -> ShowS
Vendor -> String
(Int -> Vendor -> ShowS)
-> (Vendor -> String) -> ([Vendor] -> ShowS) -> Show Vendor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Vendor -> ShowS
showsPrec :: Int -> Vendor -> ShowS
$cshow :: Vendor -> String
show :: Vendor -> String
$cshowList :: [Vendor] -> ShowS
showList :: [Vendor] -> ShowS
Show, Typeable)

-- | A 'First'-like semigroup instance that simply drops the RHS, unless the LHS
-- is 'UnknownVendor'.
instance Semigroup Vendor where
  Vendor
a <> :: Vendor -> Vendor -> Vendor
<> UnknownVendor{} = Vendor
a
  UnknownVendor{} <> Vendor
b = Vendor
b
  Vendor
a <> Vendor
_ = Vendor
a

-- | @'mempty' == 'UnknownVendor'@
instance Monoid Vendor where
  mempty :: Vendor
mempty = Vendor
UnknownVendor

-- | The constructors of this type exactly mirror the LLVM @enum OSType@,
-- including ordering and grouping.
--
-- End-of-line comments from LLVM are reproduced as constructor comments.
--
-- Last updated: LLVM 15.0.1:
-- https://github.com/llvm/llvm-project/blob/llvmorg-15.0.1/llvm/include/llvm/ADT/Triple.h#L181
data OS
  = UnknownOS
  | Ananas
  | CloudABI
  | Darwin
  | DragonFly
  | FreeBSD
  | Fuchsia
  | IOS
  | KFreeBSD
  | Linux
    -- | PS3
  | Lv2
  | MacOSX
  | NetBSD
  | OpenBSD
  | Solaris
  | Win32
  | ZOS
  | Haiku
  | Minix
  | RTEMS
    -- | Native Client
  | NaCl
  | AIX
    -- | NVIDIA CUDA
  | CUDA
    -- | NVIDIA OpenCL
  | NVCL
    -- | AMD HSA Runtime
  | AMDHSA
  | PS4
  | PS5
  | ELFIAMCU
    -- | Apple tvOS
  | TvOS
    -- | Apple watchOS
  | WatchOS
    -- | Apple DriverKit
  | DriverKit
  | Mesa3D
  | Contiki
    -- | AMD PAL Runtime
  | AMDPAL
    -- | HermitCore Unikernel/Multikernel
  | HermitCore
    -- | GNU/Hurd
  | Hurd
    -- | Experimental WebAssembly OS
  | WASI
  | Emscripten
    -- | DirectX ShaderModel
  | ShaderModel
  deriving (OS
OS -> OS -> Bounded OS
forall a. a -> a -> Bounded a
$cminBound :: OS
minBound :: OS
$cmaxBound :: OS
maxBound :: OS
Bounded, Typeable OS
Typeable OS =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OS -> c OS)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OS)
-> (OS -> Constr)
-> (OS -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OS))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OS))
-> ((forall b. Data b => b -> b) -> OS -> OS)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OS -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OS -> r)
-> (forall u. (forall d. Data d => d -> u) -> OS -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> OS -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OS -> m OS)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OS -> m OS)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OS -> m OS)
-> Data OS
OS -> Constr
OS -> DataType
(forall b. Data b => b -> b) -> OS -> OS
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) -> OS -> u
forall u. (forall d. Data d => d -> u) -> OS -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OS -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OS -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OS -> m OS
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OS -> m OS
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OS
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OS -> c OS
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OS)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OS)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OS -> c OS
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OS -> c OS
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OS
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OS
$ctoConstr :: OS -> Constr
toConstr :: OS -> Constr
$cdataTypeOf :: OS -> DataType
dataTypeOf :: OS -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OS)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OS)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OS)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OS)
$cgmapT :: (forall b. Data b => b -> b) -> OS -> OS
gmapT :: (forall b. Data b => b -> b) -> OS -> OS
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OS -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OS -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OS -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OS -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OS -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> OS -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OS -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OS -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OS -> m OS
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OS -> m OS
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OS -> m OS
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OS -> m OS
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OS -> m OS
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OS -> m OS
Data, Int -> OS
OS -> Int
OS -> [OS]
OS -> OS
OS -> OS -> [OS]
OS -> OS -> OS -> [OS]
(OS -> OS)
-> (OS -> OS)
-> (Int -> OS)
-> (OS -> Int)
-> (OS -> [OS])
-> (OS -> OS -> [OS])
-> (OS -> OS -> [OS])
-> (OS -> OS -> OS -> [OS])
-> Enum OS
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: OS -> OS
succ :: OS -> OS
$cpred :: OS -> OS
pred :: OS -> OS
$ctoEnum :: Int -> OS
toEnum :: Int -> OS
$cfromEnum :: OS -> Int
fromEnum :: OS -> Int
$cenumFrom :: OS -> [OS]
enumFrom :: OS -> [OS]
$cenumFromThen :: OS -> OS -> [OS]
enumFromThen :: OS -> OS -> [OS]
$cenumFromTo :: OS -> OS -> [OS]
enumFromTo :: OS -> OS -> [OS]
$cenumFromThenTo :: OS -> OS -> OS -> [OS]
enumFromThenTo :: OS -> OS -> OS -> [OS]
Enum, OS -> OS -> Bool
(OS -> OS -> Bool) -> (OS -> OS -> Bool) -> Eq OS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OS -> OS -> Bool
== :: OS -> OS -> Bool
$c/= :: OS -> OS -> Bool
/= :: OS -> OS -> Bool
Eq, (forall x. OS -> Rep OS x)
-> (forall x. Rep OS x -> OS) -> Generic OS
forall x. Rep OS x -> OS
forall x. OS -> Rep OS x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OS -> Rep OS x
from :: forall x. OS -> Rep OS x
$cto :: forall x. Rep OS x -> OS
to :: forall x. Rep OS x -> OS
Generic, Eq OS
Eq OS =>
(OS -> OS -> Ordering)
-> (OS -> OS -> Bool)
-> (OS -> OS -> Bool)
-> (OS -> OS -> Bool)
-> (OS -> OS -> Bool)
-> (OS -> OS -> OS)
-> (OS -> OS -> OS)
-> Ord OS
OS -> OS -> Bool
OS -> OS -> Ordering
OS -> OS -> OS
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 :: OS -> OS -> Ordering
compare :: OS -> OS -> Ordering
$c< :: OS -> OS -> Bool
< :: OS -> OS -> Bool
$c<= :: OS -> OS -> Bool
<= :: OS -> OS -> Bool
$c> :: OS -> OS -> Bool
> :: OS -> OS -> Bool
$c>= :: OS -> OS -> Bool
>= :: OS -> OS -> Bool
$cmax :: OS -> OS -> OS
max :: OS -> OS -> OS
$cmin :: OS -> OS -> OS
min :: OS -> OS -> OS
Ord, ReadPrec [OS]
ReadPrec OS
Int -> ReadS OS
ReadS [OS]
(Int -> ReadS OS)
-> ReadS [OS] -> ReadPrec OS -> ReadPrec [OS] -> Read OS
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OS
readsPrec :: Int -> ReadS OS
$creadList :: ReadS [OS]
readList :: ReadS [OS]
$creadPrec :: ReadPrec OS
readPrec :: ReadPrec OS
$creadListPrec :: ReadPrec [OS]
readListPrec :: ReadPrec [OS]
Read, Int -> OS -> ShowS
[OS] -> ShowS
OS -> String
(Int -> OS -> ShowS)
-> (OS -> String) -> ([OS] -> ShowS) -> Show OS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OS -> ShowS
showsPrec :: Int -> OS -> ShowS
$cshow :: OS -> String
show :: OS -> String
$cshowList :: [OS] -> ShowS
showList :: [OS] -> ShowS
Show, Typeable)

-- | A 'First'-like semigroup instance that simply drops the RHS, unless the LHS
-- is 'UnknownOS'.
instance Semigroup OS where
  OS
a <> :: OS -> OS -> OS
<> UnknownOS{} = OS
a
  UnknownOS{} <> OS
b = OS
b
  OS
a <> OS
_ = OS
a

-- | @'mempty' == 'UnknownOS'@
instance Monoid OS where
  mempty :: OS
mempty = OS
UnknownOS

-- | The constructors of this type exactly mirror the LLVM @enum
-- EnvironmentType@, including ordering and grouping.
--
-- End-of-line comments from LLVM are reproduced as constructor comments.
--
-- Last updated: LLVM 15.0.1:
-- https://github.com/llvm/llvm-project/blob/llvmorg-15.0.1/llvm/include/llvm/ADT/Triple.h#L224
data Environment
  = UnknownEnvironment

  | GNU
  | GNUABIN32
  | GNUABI64
  | GNUEABI
  | GNUEABIHF
  | GNUX32
  | GNUILP32
  | CODE16
  | EABI
  | EABIHF
  | Android
  | Musl
  | MuslEABI
  | MuslEABIHF
  | MuslX32

  | MSVC
  | Itanium
  | Cygnus
  | CoreCLR
    -- | Simulator variants of other systems e.g. Apple's iOS
  | Simulator
    -- | Mac Catalyst variant of Apple's iOS deployment target.
  | MacABI

  | Pixel
  | Vertex
  | Geometry
  | Hull
  | Domain
  | Compute
  | Library
  | RayGeneration
  | Intersection
  | AnyHit
  | ClosestHit
  | Miss
  | Callable
  | Mesh
  | Amplification
  deriving (Environment
Environment -> Environment -> Bounded Environment
forall a. a -> a -> Bounded a
$cminBound :: Environment
minBound :: Environment
$cmaxBound :: Environment
maxBound :: Environment
Bounded, Typeable Environment
Typeable Environment =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Environment -> c Environment)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Environment)
-> (Environment -> Constr)
-> (Environment -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Environment))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Environment))
-> ((forall b. Data b => b -> b) -> Environment -> Environment)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Environment -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Environment -> r)
-> (forall u. (forall d. Data d => d -> u) -> Environment -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Environment -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Environment -> m Environment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Environment -> m Environment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Environment -> m Environment)
-> Data Environment
Environment -> Constr
Environment -> DataType
(forall b. Data b => b -> b) -> Environment -> Environment
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) -> Environment -> u
forall u. (forall d. Data d => d -> u) -> Environment -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Environment -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Environment -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Environment -> m Environment
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Environment -> m Environment
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Environment
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Environment -> c Environment
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Environment)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Environment)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Environment -> c Environment
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Environment -> c Environment
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Environment
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Environment
$ctoConstr :: Environment -> Constr
toConstr :: Environment -> Constr
$cdataTypeOf :: Environment -> DataType
dataTypeOf :: Environment -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Environment)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Environment)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Environment)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Environment)
$cgmapT :: (forall b. Data b => b -> b) -> Environment -> Environment
gmapT :: (forall b. Data b => b -> b) -> Environment -> Environment
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Environment -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Environment -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Environment -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Environment -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Environment -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Environment -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Environment -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Environment -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Environment -> m Environment
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Environment -> m Environment
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Environment -> m Environment
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Environment -> m Environment
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Environment -> m Environment
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Environment -> m Environment
Data, Int -> Environment
Environment -> Int
Environment -> [Environment]
Environment -> Environment
Environment -> Environment -> [Environment]
Environment -> Environment -> Environment -> [Environment]
(Environment -> Environment)
-> (Environment -> Environment)
-> (Int -> Environment)
-> (Environment -> Int)
-> (Environment -> [Environment])
-> (Environment -> Environment -> [Environment])
-> (Environment -> Environment -> [Environment])
-> (Environment -> Environment -> Environment -> [Environment])
-> Enum Environment
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Environment -> Environment
succ :: Environment -> Environment
$cpred :: Environment -> Environment
pred :: Environment -> Environment
$ctoEnum :: Int -> Environment
toEnum :: Int -> Environment
$cfromEnum :: Environment -> Int
fromEnum :: Environment -> Int
$cenumFrom :: Environment -> [Environment]
enumFrom :: Environment -> [Environment]
$cenumFromThen :: Environment -> Environment -> [Environment]
enumFromThen :: Environment -> Environment -> [Environment]
$cenumFromTo :: Environment -> Environment -> [Environment]
enumFromTo :: Environment -> Environment -> [Environment]
$cenumFromThenTo :: Environment -> Environment -> Environment -> [Environment]
enumFromThenTo :: Environment -> Environment -> Environment -> [Environment]
Enum, Environment -> Environment -> Bool
(Environment -> Environment -> Bool)
-> (Environment -> Environment -> Bool) -> Eq Environment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Environment -> Environment -> Bool
== :: Environment -> Environment -> Bool
$c/= :: Environment -> Environment -> Bool
/= :: Environment -> Environment -> Bool
Eq, (forall x. Environment -> Rep Environment x)
-> (forall x. Rep Environment x -> Environment)
-> Generic Environment
forall x. Rep Environment x -> Environment
forall x. Environment -> Rep Environment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Environment -> Rep Environment x
from :: forall x. Environment -> Rep Environment x
$cto :: forall x. Rep Environment x -> Environment
to :: forall x. Rep Environment x -> Environment
Generic, Eq Environment
Eq Environment =>
(Environment -> Environment -> Ordering)
-> (Environment -> Environment -> Bool)
-> (Environment -> Environment -> Bool)
-> (Environment -> Environment -> Bool)
-> (Environment -> Environment -> Bool)
-> (Environment -> Environment -> Environment)
-> (Environment -> Environment -> Environment)
-> Ord Environment
Environment -> Environment -> Bool
Environment -> Environment -> Ordering
Environment -> Environment -> Environment
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 :: Environment -> Environment -> Ordering
compare :: Environment -> Environment -> Ordering
$c< :: Environment -> Environment -> Bool
< :: Environment -> Environment -> Bool
$c<= :: Environment -> Environment -> Bool
<= :: Environment -> Environment -> Bool
$c> :: Environment -> Environment -> Bool
> :: Environment -> Environment -> Bool
$c>= :: Environment -> Environment -> Bool
>= :: Environment -> Environment -> Bool
$cmax :: Environment -> Environment -> Environment
max :: Environment -> Environment -> Environment
$cmin :: Environment -> Environment -> Environment
min :: Environment -> Environment -> Environment
Ord, ReadPrec [Environment]
ReadPrec Environment
Int -> ReadS Environment
ReadS [Environment]
(Int -> ReadS Environment)
-> ReadS [Environment]
-> ReadPrec Environment
-> ReadPrec [Environment]
-> Read Environment
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Environment
readsPrec :: Int -> ReadS Environment
$creadList :: ReadS [Environment]
readList :: ReadS [Environment]
$creadPrec :: ReadPrec Environment
readPrec :: ReadPrec Environment
$creadListPrec :: ReadPrec [Environment]
readListPrec :: ReadPrec [Environment]
Read, Int -> Environment -> ShowS
[Environment] -> ShowS
Environment -> String
(Int -> Environment -> ShowS)
-> (Environment -> String)
-> ([Environment] -> ShowS)
-> Show Environment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Environment -> ShowS
showsPrec :: Int -> Environment -> ShowS
$cshow :: Environment -> String
show :: Environment -> String
$cshowList :: [Environment] -> ShowS
showList :: [Environment] -> ShowS
Show, Typeable)

-- | A 'First'-like semigroup instance that simply drops the RHS, unless the LHS
-- is 'UnknownEnvironment'.
instance Semigroup Environment where
  Environment
a <> :: Environment -> Environment -> Environment
<> UnknownEnvironment{} = Environment
a
  UnknownEnvironment{} <> Environment
b = Environment
b
  Environment
a <> Environment
_ = Environment
a

-- | @'mempty' == 'UnknownEnvironment'@
instance Monoid Environment where
  mempty :: Environment
mempty = Environment
UnknownEnvironment

-- | The constructors of this type exactly mirror the LLVM @enum
-- ObjectFormatType@, including ordering.
--
-- Last updated: LLVM 15.0.1:
-- https://github.com/llvm/llvm-project/blob/llvmorg-15.0.1/llvm/include/llvm/ADT/Triple.h#L269
data ObjectFormat
  = UnknownObjectFormat
  | COFF
  | DXContainer
  | ELF
  | GOFF
  | MachO
  | SPIRV
  | Wasm
  | XCOFF
  deriving (ObjectFormat
ObjectFormat -> ObjectFormat -> Bounded ObjectFormat
forall a. a -> a -> Bounded a
$cminBound :: ObjectFormat
minBound :: ObjectFormat
$cmaxBound :: ObjectFormat
maxBound :: ObjectFormat
Bounded, Typeable ObjectFormat
Typeable ObjectFormat =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ObjectFormat -> c ObjectFormat)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ObjectFormat)
-> (ObjectFormat -> Constr)
-> (ObjectFormat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ObjectFormat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ObjectFormat))
-> ((forall b. Data b => b -> b) -> ObjectFormat -> ObjectFormat)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjectFormat -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjectFormat -> r)
-> (forall u. (forall d. Data d => d -> u) -> ObjectFormat -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ObjectFormat -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ObjectFormat -> m ObjectFormat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ObjectFormat -> m ObjectFormat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ObjectFormat -> m ObjectFormat)
-> Data ObjectFormat
ObjectFormat -> Constr
ObjectFormat -> DataType
(forall b. Data b => b -> b) -> ObjectFormat -> ObjectFormat
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) -> ObjectFormat -> u
forall u. (forall d. Data d => d -> u) -> ObjectFormat -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectFormat -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectFormat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectFormat -> m ObjectFormat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectFormat -> m ObjectFormat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectFormat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectFormat -> c ObjectFormat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectFormat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectFormat)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectFormat -> c ObjectFormat
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectFormat -> c ObjectFormat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectFormat
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectFormat
$ctoConstr :: ObjectFormat -> Constr
toConstr :: ObjectFormat -> Constr
$cdataTypeOf :: ObjectFormat -> DataType
dataTypeOf :: ObjectFormat -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectFormat)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectFormat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectFormat)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectFormat)
$cgmapT :: (forall b. Data b => b -> b) -> ObjectFormat -> ObjectFormat
gmapT :: (forall b. Data b => b -> b) -> ObjectFormat -> ObjectFormat
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectFormat -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectFormat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectFormat -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectFormat -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ObjectFormat -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ObjectFormat -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ObjectFormat -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ObjectFormat -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectFormat -> m ObjectFormat
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectFormat -> m ObjectFormat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectFormat -> m ObjectFormat
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectFormat -> m ObjectFormat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectFormat -> m ObjectFormat
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectFormat -> m ObjectFormat
Data, Int -> ObjectFormat
ObjectFormat -> Int
ObjectFormat -> [ObjectFormat]
ObjectFormat -> ObjectFormat
ObjectFormat -> ObjectFormat -> [ObjectFormat]
ObjectFormat -> ObjectFormat -> ObjectFormat -> [ObjectFormat]
(ObjectFormat -> ObjectFormat)
-> (ObjectFormat -> ObjectFormat)
-> (Int -> ObjectFormat)
-> (ObjectFormat -> Int)
-> (ObjectFormat -> [ObjectFormat])
-> (ObjectFormat -> ObjectFormat -> [ObjectFormat])
-> (ObjectFormat -> ObjectFormat -> [ObjectFormat])
-> (ObjectFormat -> ObjectFormat -> ObjectFormat -> [ObjectFormat])
-> Enum ObjectFormat
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ObjectFormat -> ObjectFormat
succ :: ObjectFormat -> ObjectFormat
$cpred :: ObjectFormat -> ObjectFormat
pred :: ObjectFormat -> ObjectFormat
$ctoEnum :: Int -> ObjectFormat
toEnum :: Int -> ObjectFormat
$cfromEnum :: ObjectFormat -> Int
fromEnum :: ObjectFormat -> Int
$cenumFrom :: ObjectFormat -> [ObjectFormat]
enumFrom :: ObjectFormat -> [ObjectFormat]
$cenumFromThen :: ObjectFormat -> ObjectFormat -> [ObjectFormat]
enumFromThen :: ObjectFormat -> ObjectFormat -> [ObjectFormat]
$cenumFromTo :: ObjectFormat -> ObjectFormat -> [ObjectFormat]
enumFromTo :: ObjectFormat -> ObjectFormat -> [ObjectFormat]
$cenumFromThenTo :: ObjectFormat -> ObjectFormat -> ObjectFormat -> [ObjectFormat]
enumFromThenTo :: ObjectFormat -> ObjectFormat -> ObjectFormat -> [ObjectFormat]
Enum, ObjectFormat -> ObjectFormat -> Bool
(ObjectFormat -> ObjectFormat -> Bool)
-> (ObjectFormat -> ObjectFormat -> Bool) -> Eq ObjectFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ObjectFormat -> ObjectFormat -> Bool
== :: ObjectFormat -> ObjectFormat -> Bool
$c/= :: ObjectFormat -> ObjectFormat -> Bool
/= :: ObjectFormat -> ObjectFormat -> Bool
Eq, (forall x. ObjectFormat -> Rep ObjectFormat x)
-> (forall x. Rep ObjectFormat x -> ObjectFormat)
-> Generic ObjectFormat
forall x. Rep ObjectFormat x -> ObjectFormat
forall x. ObjectFormat -> Rep ObjectFormat x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ObjectFormat -> Rep ObjectFormat x
from :: forall x. ObjectFormat -> Rep ObjectFormat x
$cto :: forall x. Rep ObjectFormat x -> ObjectFormat
to :: forall x. Rep ObjectFormat x -> ObjectFormat
Generic, Eq ObjectFormat
Eq ObjectFormat =>
(ObjectFormat -> ObjectFormat -> Ordering)
-> (ObjectFormat -> ObjectFormat -> Bool)
-> (ObjectFormat -> ObjectFormat -> Bool)
-> (ObjectFormat -> ObjectFormat -> Bool)
-> (ObjectFormat -> ObjectFormat -> Bool)
-> (ObjectFormat -> ObjectFormat -> ObjectFormat)
-> (ObjectFormat -> ObjectFormat -> ObjectFormat)
-> Ord ObjectFormat
ObjectFormat -> ObjectFormat -> Bool
ObjectFormat -> ObjectFormat -> Ordering
ObjectFormat -> ObjectFormat -> ObjectFormat
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 :: ObjectFormat -> ObjectFormat -> Ordering
compare :: ObjectFormat -> ObjectFormat -> Ordering
$c< :: ObjectFormat -> ObjectFormat -> Bool
< :: ObjectFormat -> ObjectFormat -> Bool
$c<= :: ObjectFormat -> ObjectFormat -> Bool
<= :: ObjectFormat -> ObjectFormat -> Bool
$c> :: ObjectFormat -> ObjectFormat -> Bool
> :: ObjectFormat -> ObjectFormat -> Bool
$c>= :: ObjectFormat -> ObjectFormat -> Bool
>= :: ObjectFormat -> ObjectFormat -> Bool
$cmax :: ObjectFormat -> ObjectFormat -> ObjectFormat
max :: ObjectFormat -> ObjectFormat -> ObjectFormat
$cmin :: ObjectFormat -> ObjectFormat -> ObjectFormat
min :: ObjectFormat -> ObjectFormat -> ObjectFormat
Ord, ReadPrec [ObjectFormat]
ReadPrec ObjectFormat
Int -> ReadS ObjectFormat
ReadS [ObjectFormat]
(Int -> ReadS ObjectFormat)
-> ReadS [ObjectFormat]
-> ReadPrec ObjectFormat
-> ReadPrec [ObjectFormat]
-> Read ObjectFormat
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ObjectFormat
readsPrec :: Int -> ReadS ObjectFormat
$creadList :: ReadS [ObjectFormat]
readList :: ReadS [ObjectFormat]
$creadPrec :: ReadPrec ObjectFormat
readPrec :: ReadPrec ObjectFormat
$creadListPrec :: ReadPrec [ObjectFormat]
readListPrec :: ReadPrec [ObjectFormat]
Read, Int -> ObjectFormat -> ShowS
[ObjectFormat] -> ShowS
ObjectFormat -> String
(Int -> ObjectFormat -> ShowS)
-> (ObjectFormat -> String)
-> ([ObjectFormat] -> ShowS)
-> Show ObjectFormat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ObjectFormat -> ShowS
showsPrec :: Int -> ObjectFormat -> ShowS
$cshow :: ObjectFormat -> String
show :: ObjectFormat -> String
$cshowList :: [ObjectFormat] -> ShowS
showList :: [ObjectFormat] -> ShowS
Show, Typeable)

-- | A 'First'-like semigroup instance that simply drops the RHS, unless the LHS
-- is 'UnknownObjectFormat'.
instance Semigroup ObjectFormat where
  ObjectFormat
a <> :: ObjectFormat -> ObjectFormat -> ObjectFormat
<> UnknownObjectFormat{} = ObjectFormat
a
  UnknownObjectFormat{} <> ObjectFormat
b = ObjectFormat
b
  ObjectFormat
a <> ObjectFormat
_ = ObjectFormat
a

-- | @'mempty' == 'UnknownObjectFormat'@
instance Monoid ObjectFormat where
  mempty :: ObjectFormat
mempty = ObjectFormat
UnknownObjectFormat

-- | More like a sextuple than a triple, if you think about it.
--
-- The LLVM version of this holds onto the un-normalized string representation.
-- We discard it.
data TargetTriple
  = TargetTriple
    { TargetTriple -> Arch
ttArch :: Arch
    , TargetTriple -> SubArch
ttSubArch :: SubArch
    , TargetTriple -> Vendor
ttVendor :: Vendor
    , TargetTriple -> OS
ttOS :: OS
    , TargetTriple -> Environment
ttEnv :: Environment
    , TargetTriple -> ObjectFormat
ttObjFmt :: ObjectFormat
    }
  deriving (TargetTriple
TargetTriple -> TargetTriple -> Bounded TargetTriple
forall a. a -> a -> Bounded a
$cminBound :: TargetTriple
minBound :: TargetTriple
$cmaxBound :: TargetTriple
maxBound :: TargetTriple
Bounded, Typeable TargetTriple
Typeable TargetTriple =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TargetTriple -> c TargetTriple)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TargetTriple)
-> (TargetTriple -> Constr)
-> (TargetTriple -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TargetTriple))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TargetTriple))
-> ((forall b. Data b => b -> b) -> TargetTriple -> TargetTriple)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TargetTriple -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TargetTriple -> r)
-> (forall u. (forall d. Data d => d -> u) -> TargetTriple -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TargetTriple -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TargetTriple -> m TargetTriple)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TargetTriple -> m TargetTriple)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TargetTriple -> m TargetTriple)
-> Data TargetTriple
TargetTriple -> Constr
TargetTriple -> DataType
(forall b. Data b => b -> b) -> TargetTriple -> TargetTriple
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) -> TargetTriple -> u
forall u. (forall d. Data d => d -> u) -> TargetTriple -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TargetTriple -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TargetTriple -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TargetTriple -> m TargetTriple
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TargetTriple -> m TargetTriple
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TargetTriple
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TargetTriple -> c TargetTriple
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TargetTriple)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TargetTriple)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TargetTriple -> c TargetTriple
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TargetTriple -> c TargetTriple
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TargetTriple
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TargetTriple
$ctoConstr :: TargetTriple -> Constr
toConstr :: TargetTriple -> Constr
$cdataTypeOf :: TargetTriple -> DataType
dataTypeOf :: TargetTriple -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TargetTriple)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TargetTriple)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TargetTriple)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TargetTriple)
$cgmapT :: (forall b. Data b => b -> b) -> TargetTriple -> TargetTriple
gmapT :: (forall b. Data b => b -> b) -> TargetTriple -> TargetTriple
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TargetTriple -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TargetTriple -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TargetTriple -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TargetTriple -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TargetTriple -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TargetTriple -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TargetTriple -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TargetTriple -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TargetTriple -> m TargetTriple
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TargetTriple -> m TargetTriple
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TargetTriple -> m TargetTriple
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TargetTriple -> m TargetTriple
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TargetTriple -> m TargetTriple
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TargetTriple -> m TargetTriple
Data, TargetTriple -> TargetTriple -> Bool
(TargetTriple -> TargetTriple -> Bool)
-> (TargetTriple -> TargetTriple -> Bool) -> Eq TargetTriple
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TargetTriple -> TargetTriple -> Bool
== :: TargetTriple -> TargetTriple -> Bool
$c/= :: TargetTriple -> TargetTriple -> Bool
/= :: TargetTriple -> TargetTriple -> Bool
Eq, (forall x. TargetTriple -> Rep TargetTriple x)
-> (forall x. Rep TargetTriple x -> TargetTriple)
-> Generic TargetTriple
forall x. Rep TargetTriple x -> TargetTriple
forall x. TargetTriple -> Rep TargetTriple x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TargetTriple -> Rep TargetTriple x
from :: forall x. TargetTriple -> Rep TargetTriple x
$cto :: forall x. Rep TargetTriple x -> TargetTriple
to :: forall x. Rep TargetTriple x -> TargetTriple
Generic, Eq TargetTriple
Eq TargetTriple =>
(TargetTriple -> TargetTriple -> Ordering)
-> (TargetTriple -> TargetTriple -> Bool)
-> (TargetTriple -> TargetTriple -> Bool)
-> (TargetTriple -> TargetTriple -> Bool)
-> (TargetTriple -> TargetTriple -> Bool)
-> (TargetTriple -> TargetTriple -> TargetTriple)
-> (TargetTriple -> TargetTriple -> TargetTriple)
-> Ord TargetTriple
TargetTriple -> TargetTriple -> Bool
TargetTriple -> TargetTriple -> Ordering
TargetTriple -> TargetTriple -> TargetTriple
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 :: TargetTriple -> TargetTriple -> Ordering
compare :: TargetTriple -> TargetTriple -> Ordering
$c< :: TargetTriple -> TargetTriple -> Bool
< :: TargetTriple -> TargetTriple -> Bool
$c<= :: TargetTriple -> TargetTriple -> Bool
<= :: TargetTriple -> TargetTriple -> Bool
$c> :: TargetTriple -> TargetTriple -> Bool
> :: TargetTriple -> TargetTriple -> Bool
$c>= :: TargetTriple -> TargetTriple -> Bool
>= :: TargetTriple -> TargetTriple -> Bool
$cmax :: TargetTriple -> TargetTriple -> TargetTriple
max :: TargetTriple -> TargetTriple -> TargetTriple
$cmin :: TargetTriple -> TargetTriple -> TargetTriple
min :: TargetTriple -> TargetTriple -> TargetTriple
Ord, ReadPrec [TargetTriple]
ReadPrec TargetTriple
Int -> ReadS TargetTriple
ReadS [TargetTriple]
(Int -> ReadS TargetTriple)
-> ReadS [TargetTriple]
-> ReadPrec TargetTriple
-> ReadPrec [TargetTriple]
-> Read TargetTriple
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TargetTriple
readsPrec :: Int -> ReadS TargetTriple
$creadList :: ReadS [TargetTriple]
readList :: ReadS [TargetTriple]
$creadPrec :: ReadPrec TargetTriple
readPrec :: ReadPrec TargetTriple
$creadListPrec :: ReadPrec [TargetTriple]
readListPrec :: ReadPrec [TargetTriple]
Read, Int -> TargetTriple -> ShowS
[TargetTriple] -> ShowS
TargetTriple -> String
(Int -> TargetTriple -> ShowS)
-> (TargetTriple -> String)
-> ([TargetTriple] -> ShowS)
-> Show TargetTriple
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TargetTriple -> ShowS
showsPrec :: Int -> TargetTriple -> ShowS
$cshow :: TargetTriple -> String
show :: TargetTriple -> String
$cshowList :: [TargetTriple] -> ShowS
showList :: [TargetTriple] -> ShowS
Show, Typeable)

-- | Combines fields pointwise.
instance Semigroup TargetTriple where
  TargetTriple
tt <> :: TargetTriple -> TargetTriple -> TargetTriple
<> TargetTriple
tt' =
    TargetTriple
    { ttArch :: Arch
ttArch = TargetTriple -> Arch
ttArch TargetTriple
tt Arch -> Arch -> Arch
forall a. Semigroup a => a -> a -> a
<> TargetTriple -> Arch
ttArch TargetTriple
tt'
    , ttSubArch :: SubArch
ttSubArch = TargetTriple -> SubArch
ttSubArch TargetTriple
tt SubArch -> SubArch -> SubArch
forall a. Semigroup a => a -> a -> a
<> TargetTriple -> SubArch
ttSubArch TargetTriple
tt'
    , ttVendor :: Vendor
ttVendor = TargetTriple -> Vendor
ttVendor TargetTriple
tt Vendor -> Vendor -> Vendor
forall a. Semigroup a => a -> a -> a
<> TargetTriple -> Vendor
ttVendor TargetTriple
tt'
    , ttOS :: OS
ttOS = TargetTriple -> OS
ttOS TargetTriple
tt OS -> OS -> OS
forall a. Semigroup a => a -> a -> a
<> TargetTriple -> OS
ttOS TargetTriple
tt'
    , ttEnv :: Environment
ttEnv = TargetTriple -> Environment
ttEnv TargetTriple
tt Environment -> Environment -> Environment
forall a. Semigroup a => a -> a -> a
<> TargetTriple -> Environment
ttEnv TargetTriple
tt'
    , ttObjFmt :: ObjectFormat
ttObjFmt = TargetTriple -> ObjectFormat
ttObjFmt TargetTriple
tt ObjectFormat -> ObjectFormat -> ObjectFormat
forall a. Semigroup a => a -> a -> a
<> TargetTriple -> ObjectFormat
ttObjFmt TargetTriple
tt'
    }

-- | Pointwise 'mempty'.
instance Monoid TargetTriple where
  mempty :: TargetTriple
mempty =
    TargetTriple
    { ttArch :: Arch
ttArch = Arch
forall a. Monoid a => a
mempty
    , ttSubArch :: SubArch
ttSubArch = SubArch
forall a. Monoid a => a
mempty
    , ttVendor :: Vendor
ttVendor = Vendor
forall a. Monoid a => a
mempty
    , ttOS :: OS
ttOS = OS
forall a. Monoid a => a
mempty
    , ttEnv :: Environment
ttEnv = Environment
forall a. Monoid a => a
mempty
    , ttObjFmt :: ObjectFormat
ttObjFmt = ObjectFormat
forall a. Monoid a => a
mempty
    }