{-# OPTIONS_GHC -Wno-unused-imports #-}
{-# OPTIONS_HADDOCK hide, prune, not-home #-}

module MLIR.AST.Dialect.Generated.X86Vector where

import Prelude (Int, Double, Maybe(..), Bool(..), (++), (<$>), ($), (<>), Show)
import qualified Prelude
import Data.Int (Int64)
import qualified Data.Maybe
import Data.Array (Ix)
import qualified Data.Array.IArray as IArray
import qualified Data.ByteString as BS
import qualified Data.Map.Strict as M
import qualified Control.Monad

import MLIR.AST ( Attribute(..), Type(..), AbstractOperation(..), ResultTypes(..)
                , Location(..), Signedness(..), DenseElements(..)
                , NamedAttributes, Name
                , pattern NoAttrs )
import qualified MLIR.AST as AST
import MLIR.AST.Builder (Value, EndOfBlock, MonadBlockBuilder, RegionBuilderT)
import qualified MLIR.AST.Builder as AST
import qualified MLIR.AST.IStorableArray as AST
import qualified MLIR.AST.PatternUtil as PatternUtil
import qualified MLIR.AST.Dialect.Affine as Affine

-- * avx512.dot
-- $avx512.dot
-- 
-- The @dot@ op is an AVX512-BF16 specific op that can lower to the proper
-- LLVMAVX512BF16 operation @llvm.dpbf16ps@ depending on the width of MLIR
-- vectors it is applied to.
-- 
-- \#\#\#\# From the Intel Intrinsics Guide:
-- 
-- Compute dot-product of BF16 (16-bit) floating-point pairs in @a@ and @b@,
-- accumulating the intermediate single-precision (32-bit) floating-point
-- elements with elements in @src@, and store the results in @dst@.
-- 
-- Example:
-- @
-- %0 = x86vector.avx512.dot %src, %a, %b : vector\<32xbf16> -> vector\<16xf32>
-- @
--   

-- | A pattern for @x86vector.avx512.dot@.
pattern DotBF16 :: () => () => Location -> Type -> operand -> operand -> operand -> AbstractOperation operand
pattern $bDotBF16 :: Location
-> Type
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mDotBF16 :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> operand -> operand -> operand -> r)
-> (Void# -> r)
-> r
DotBF16 loc ty0 src_ a_ b_  = Operation
          { opName = "x86vector.avx512.dot"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [src_, a_, b_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.dot@.
avx512_dot :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> m Value
avx512_dot :: Type -> Value -> Value -> Value -> m Value
avx512_dot Type
ty0 Value
src_ Value
a_ Value
b_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.dot"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
src_), (Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx512.intr.dpbf16ps.128@.
pattern DotBF16Ps128Intr :: () => () => Location -> Type -> operand -> operand -> operand -> AbstractOperation operand
pattern $bDotBF16Ps128Intr :: Location
-> Type
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mDotBF16Ps128Intr :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> operand -> operand -> operand -> r)
-> (Void# -> r)
-> r
DotBF16Ps128Intr loc ty0 src_ a_ b_  = Operation
          { opName = "x86vector.avx512.intr.dpbf16ps.128"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [src_, a_, b_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.intr.dpbf16ps.128@.
avx512_intr_dpbf16ps_128 :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> m Value
avx512_intr_dpbf16ps_128 :: Type -> Value -> Value -> Value -> m Value
avx512_intr_dpbf16ps_128 Type
ty0 Value
src_ Value
a_ Value
b_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.intr.dpbf16ps.128"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
src_), (Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx512.intr.dpbf16ps.256@.
pattern DotBF16Ps256Intr :: () => () => Location -> Type -> operand -> operand -> operand -> AbstractOperation operand
pattern $bDotBF16Ps256Intr :: Location
-> Type
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mDotBF16Ps256Intr :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> operand -> operand -> operand -> r)
-> (Void# -> r)
-> r
DotBF16Ps256Intr loc ty0 src_ a_ b_  = Operation
          { opName = "x86vector.avx512.intr.dpbf16ps.256"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [src_, a_, b_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.intr.dpbf16ps.256@.
avx512_intr_dpbf16ps_256 :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> m Value
avx512_intr_dpbf16ps_256 :: Type -> Value -> Value -> Value -> m Value
avx512_intr_dpbf16ps_256 Type
ty0 Value
src_ Value
a_ Value
b_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.intr.dpbf16ps.256"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
src_), (Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx512.intr.dpbf16ps.512@.
pattern DotBF16Ps512Intr :: () => () => Location -> Type -> operand -> operand -> operand -> AbstractOperation operand
pattern $bDotBF16Ps512Intr :: Location
-> Type
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mDotBF16Ps512Intr :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> operand -> operand -> operand -> r)
-> (Void# -> r)
-> r
DotBF16Ps512Intr loc ty0 src_ a_ b_  = Operation
          { opName = "x86vector.avx512.intr.dpbf16ps.512"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [src_, a_, b_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.intr.dpbf16ps.512@.
avx512_intr_dpbf16ps_512 :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> m Value
avx512_intr_dpbf16ps_512 :: Type -> Value -> Value -> Value -> m Value
avx512_intr_dpbf16ps_512 Type
ty0 Value
src_ Value
a_ Value
b_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.intr.dpbf16ps.512"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
src_), (Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx.intr.dp.ps.256@.
pattern DotIntr :: () => () => Location -> Type -> operand -> operand -> operand -> AbstractOperation operand
pattern $bDotIntr :: Location
-> Type
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mDotIntr :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> operand -> operand -> operand -> r)
-> (Void# -> r)
-> r
DotIntr loc ty0 a_ b_ c_  = Operation
          { opName = "x86vector.avx.intr.dp.ps.256"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [a_, b_, c_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx.intr.dp.ps.256@.
avx_intr_dp_ps_256 :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> m Value
avx_intr_dp_ps_256 :: Type -> Value -> Value -> Value -> m Value
avx_intr_dp_ps_256 Type
ty0 Value
a_ Value
b_ Value
c_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx.intr.dp.ps.256"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_), (Value -> Name
AST.operand Value
c_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- * avx.intr.dot
-- $avx.intr.dot
-- 
-- Computes the 4-way dot products of the lower and higher parts of the source
-- vectors and broadcasts the two results to the lower and higher elements of
-- the destination vector, respectively. Adding one element of the lower part
-- to one element of the higher part in the destination vector yields the full
-- dot product of the two source vectors.
-- 
-- Example:
-- 
-- @
-- %0 = x86vector.avx.intr.dot %a, %b : vector\<8xf32>
-- %1 = vector.extractelement %0[%i0 : i32]: vector\<8xf32>
-- %2 = vector.extractelement %0[%i4 : i32]: vector\<8xf32>
-- %d = arith.addf %1, %2 : f32
-- @
--   

-- | A pattern for @x86vector.avx.intr.dot@.
pattern Dot :: () => () => Location -> Type -> operand -> operand -> AbstractOperation operand
pattern $bDot :: Location -> Type -> operand -> operand -> AbstractOperation operand
$mDot :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> operand -> operand -> r)
-> (Void# -> r)
-> r
Dot loc ty a_ b_  = Operation
          { opName = "x86vector.avx.intr.dot"
          , opLocation = loc
          , opResultTypes = Explicit [ty]
          , opOperands = [a_, b_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx.intr.dot@.
avx_intr_dot :: () => MonadBlockBuilder m => Value -> Value -> m Value
avx_intr_dot :: Value -> Value -> m Value
avx_intr_dot  Value
a_ Value
b_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx.intr.dot"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [(Value -> Type
AST.typeOf Value
a_)]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx512.intr.mask.compress@.
pattern MaskCompressIntr :: () => () => Location -> Type -> operand -> operand -> operand -> AbstractOperation operand
pattern $bMaskCompressIntr :: Location
-> Type
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mMaskCompressIntr :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> operand -> operand -> operand -> r)
-> (Void# -> r)
-> r
MaskCompressIntr loc ty0 a_ src_ k_  = Operation
          { opName = "x86vector.avx512.intr.mask.compress"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [a_, src_, k_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.intr.mask.compress@.
avx512_intr_mask_compress :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> m Value
avx512_intr_mask_compress :: Type -> Value -> Value -> Value -> m Value
avx512_intr_mask_compress Type
ty0 Value
a_ Value
src_ Value
k_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.intr.mask.compress"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
src_), (Value -> Name
AST.operand Value
k_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- * avx512.mask.compress
-- $avx512.mask.compress
-- 
-- The mask.compress op is an AVX512 specific op that can lower to the
-- @llvm.mask.compress@ instruction. Instead of @src@, a constant vector
-- vector attribute @constant_src@ may be specified. If neither @src@ nor
-- @constant_src@ is specified, the remaining elements in the result vector are
-- set to zero.
-- 
-- \#\#\#\# From the Intel Intrinsics Guide:
-- 
-- Contiguously store the active integer/floating-point elements in @a@ (those
-- with their respective bit set in writemask @k@) to @dst@, and pass through the
-- remaining elements from @src@.
-- 

-- | A builder for @x86vector.avx512.mask.compress@.
avx512_mask_compress :: () => MonadBlockBuilder m => Type -> Value -> Value -> Maybe Value -> m Value
avx512_mask_compress :: Type -> Value -> Value -> Maybe Value -> m Value
avx512_mask_compress Type
ty0 Value
k_ Value
a_ Maybe Value
src_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.mask.compress"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = ([(Value -> Name
AST.operand Value
k_)] [Name] -> [Name] -> [Name]
forall a. [a] -> [a] -> [a]
++ [(Value -> Name
AST.operand Value
a_)] [Name] -> [Name] -> [Name]
forall a. [a] -> [a] -> [a]
++ (Maybe Name -> [Name]
forall a. Maybe a -> [a]
Data.Maybe.maybeToList (Value -> Name
AST.operand (Value -> Name) -> Maybe Value -> Maybe Name
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Value
src_)))
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- * avx512.mask.rndscale
-- $avx512.mask.rndscale
-- 
-- The mask.rndscale op is an AVX512 specific op that can lower to the proper
-- LLVMAVX512 operation: @llvm.mask.rndscale.ps.512@ or
-- @llvm.mask.rndscale.pd.512@ instruction depending on the type of vectors it
-- is applied to.
-- 
-- \#\#\#\# From the Intel Intrinsics Guide:
-- 
-- Round packed floating-point elements in @a@ to the number of fraction bits
-- specified by @imm@, and store the results in @dst@ using writemask @k@
-- (elements are copied from src when the corresponding mask bit is not set).
--   

-- | A pattern for @x86vector.avx512.mask.rndscale@.
pattern MaskRndScale :: () => () => Location -> Type -> operand -> operand -> operand -> operand -> operand -> AbstractOperation operand
pattern $bMaskRndScale :: Location
-> Type
-> operand
-> operand
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mMaskRndScale :: forall r operand.
AbstractOperation operand
-> (Location
    -> Type
    -> operand
    -> operand
    -> operand
    -> operand
    -> operand
    -> r)
-> (Void# -> r)
-> r
MaskRndScale loc ty0 src_ k_ a_ imm_ rounding_  = Operation
          { opName = "x86vector.avx512.mask.rndscale"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [src_, k_, a_, imm_, rounding_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.mask.rndscale@.
avx512_mask_rndscale :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_mask_rndscale :: Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_mask_rndscale Type
ty0 Value
src_ Value
k_ Value
a_ Value
imm_ Value
rounding_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.mask.rndscale"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
src_), (Value -> Name
AST.operand Value
k_), (Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
imm_), (Value -> Name
AST.operand Value
rounding_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx512.intr.mask.rndscale.pd.512@.
pattern MaskRndScalePDIntr :: () => () => Location -> Type -> operand -> operand -> operand -> operand -> operand -> AbstractOperation operand
pattern $bMaskRndScalePDIntr :: Location
-> Type
-> operand
-> operand
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mMaskRndScalePDIntr :: forall r operand.
AbstractOperation operand
-> (Location
    -> Type
    -> operand
    -> operand
    -> operand
    -> operand
    -> operand
    -> r)
-> (Void# -> r)
-> r
MaskRndScalePDIntr loc ty0 src_ k_ a_ imm_ rounding_  = Operation
          { opName = "x86vector.avx512.intr.mask.rndscale.pd.512"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [src_, k_, a_, imm_, rounding_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.intr.mask.rndscale.pd.512@.
avx512_intr_mask_rndscale_pd_512 :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_intr_mask_rndscale_pd_512 :: Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_intr_mask_rndscale_pd_512 Type
ty0 Value
src_ Value
k_ Value
a_ Value
imm_ Value
rounding_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.intr.mask.rndscale.pd.512"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
src_), (Value -> Name
AST.operand Value
k_), (Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
imm_), (Value -> Name
AST.operand Value
rounding_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx512.intr.mask.rndscale.ps.512@.
pattern MaskRndScalePSIntr :: () => () => Location -> Type -> operand -> operand -> operand -> operand -> operand -> AbstractOperation operand
pattern $bMaskRndScalePSIntr :: Location
-> Type
-> operand
-> operand
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mMaskRndScalePSIntr :: forall r operand.
AbstractOperation operand
-> (Location
    -> Type
    -> operand
    -> operand
    -> operand
    -> operand
    -> operand
    -> r)
-> (Void# -> r)
-> r
MaskRndScalePSIntr loc ty0 src_ k_ a_ imm_ rounding_  = Operation
          { opName = "x86vector.avx512.intr.mask.rndscale.ps.512"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [src_, k_, a_, imm_, rounding_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.intr.mask.rndscale.ps.512@.
avx512_intr_mask_rndscale_ps_512 :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_intr_mask_rndscale_ps_512 :: Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_intr_mask_rndscale_ps_512 Type
ty0 Value
src_ Value
k_ Value
a_ Value
imm_ Value
rounding_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.intr.mask.rndscale.ps.512"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
src_), (Value -> Name
AST.operand Value
k_), (Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
imm_), (Value -> Name
AST.operand Value
rounding_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- * avx512.mask.scalef
-- $avx512.mask.scalef
-- 
-- The @mask.scalef@ op is an AVX512 specific op that can lower to the proper
-- LLVMAVX512 operation: @llvm.mask.scalef.ps.512@ or
-- @llvm.mask.scalef.pd.512@ depending on the type of MLIR vectors it is
-- applied to.
-- 
-- \#\#\#\# From the Intel Intrinsics Guide:
-- 
-- Scale the packed floating-point elements in @a@ using values from @b@, and
-- store the results in @dst@ using writemask @k@ (elements are copied from src
-- when the corresponding mask bit is not set).
--   

-- | A pattern for @x86vector.avx512.mask.scalef@.
pattern MaskScaleF :: () => () => Location -> Type -> operand -> operand -> operand -> operand -> operand -> AbstractOperation operand
pattern $bMaskScaleF :: Location
-> Type
-> operand
-> operand
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mMaskScaleF :: forall r operand.
AbstractOperation operand
-> (Location
    -> Type
    -> operand
    -> operand
    -> operand
    -> operand
    -> operand
    -> r)
-> (Void# -> r)
-> r
MaskScaleF loc ty0 src_ a_ b_ k_ rounding_  = Operation
          { opName = "x86vector.avx512.mask.scalef"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [src_, a_, b_, k_, rounding_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.mask.scalef@.
avx512_mask_scalef :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_mask_scalef :: Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_mask_scalef Type
ty0 Value
src_ Value
a_ Value
b_ Value
k_ Value
rounding_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.mask.scalef"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
src_), (Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_), (Value -> Name
AST.operand Value
k_), (Value -> Name
AST.operand Value
rounding_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx512.intr.mask.scalef.pd.512@.
pattern MaskScaleFPDIntr :: () => () => Location -> Type -> operand -> operand -> operand -> operand -> operand -> AbstractOperation operand
pattern $bMaskScaleFPDIntr :: Location
-> Type
-> operand
-> operand
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mMaskScaleFPDIntr :: forall r operand.
AbstractOperation operand
-> (Location
    -> Type
    -> operand
    -> operand
    -> operand
    -> operand
    -> operand
    -> r)
-> (Void# -> r)
-> r
MaskScaleFPDIntr loc ty0 src_ a_ b_ k_ rounding_  = Operation
          { opName = "x86vector.avx512.intr.mask.scalef.pd.512"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [src_, a_, b_, k_, rounding_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.intr.mask.scalef.pd.512@.
avx512_intr_mask_scalef_pd_512 :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_intr_mask_scalef_pd_512 :: Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_intr_mask_scalef_pd_512 Type
ty0 Value
src_ Value
a_ Value
b_ Value
k_ Value
rounding_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.intr.mask.scalef.pd.512"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
src_), (Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_), (Value -> Name
AST.operand Value
k_), (Value -> Name
AST.operand Value
rounding_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx512.intr.mask.scalef.ps.512@.
pattern MaskScaleFPSIntr :: () => () => Location -> Type -> operand -> operand -> operand -> operand -> operand -> AbstractOperation operand
pattern $bMaskScaleFPSIntr :: Location
-> Type
-> operand
-> operand
-> operand
-> operand
-> operand
-> AbstractOperation operand
$mMaskScaleFPSIntr :: forall r operand.
AbstractOperation operand
-> (Location
    -> Type
    -> operand
    -> operand
    -> operand
    -> operand
    -> operand
    -> r)
-> (Void# -> r)
-> r
MaskScaleFPSIntr loc ty0 src_ a_ b_ k_ rounding_  = Operation
          { opName = "x86vector.avx512.intr.mask.scalef.ps.512"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [src_, a_, b_, k_, rounding_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.intr.mask.scalef.ps.512@.
avx512_intr_mask_scalef_ps_512 :: () => MonadBlockBuilder m => Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_intr_mask_scalef_ps_512 :: Type -> Value -> Value -> Value -> Value -> Value -> m Value
avx512_intr_mask_scalef_ps_512 Type
ty0 Value
src_ Value
a_ Value
b_ Value
k_ Value
rounding_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.intr.mask.scalef.ps.512"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
src_), (Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_), (Value -> Name
AST.operand Value
k_), (Value -> Name
AST.operand Value
rounding_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx.intr.rsqrt.ps.256@.
pattern RsqrtIntr :: () => () => Location -> Type -> operand -> AbstractOperation operand
pattern $bRsqrtIntr :: Location -> Type -> operand -> AbstractOperation operand
$mRsqrtIntr :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> operand -> r) -> (Void# -> r) -> r
RsqrtIntr loc ty a_  = Operation
          { opName = "x86vector.avx.intr.rsqrt.ps.256"
          , opLocation = loc
          , opResultTypes = Explicit [ty]
          , opOperands = [a_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx.intr.rsqrt.ps.256@.
avx_intr_rsqrt_ps_256 :: () => MonadBlockBuilder m => Value -> m Value
avx_intr_rsqrt_ps_256 :: Value -> m Value
avx_intr_rsqrt_ps_256  Value
a_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx.intr.rsqrt.ps.256"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [(Value -> Type
AST.typeOf Value
a_)]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
a_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx.rsqrt@.
pattern Rsqrt :: () => () => Location -> Type -> operand -> AbstractOperation operand
pattern $bRsqrt :: Location -> Type -> operand -> AbstractOperation operand
$mRsqrt :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> operand -> r) -> (Void# -> r) -> r
Rsqrt loc ty a_  = Operation
          { opName = "x86vector.avx.rsqrt"
          , opLocation = loc
          , opResultTypes = Explicit [ty]
          , opOperands = [a_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx.rsqrt@.
avx_rsqrt :: () => MonadBlockBuilder m => Value -> m Value
avx_rsqrt :: Value -> m Value
avx_rsqrt  Value
a_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx.rsqrt"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [(Value -> Type
AST.typeOf Value
a_)]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
a_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx512.intr.vp2intersect.d.512@.
pattern Vp2IntersectDIntr :: () => () => Location -> Type -> operand -> operand -> AbstractOperation operand
pattern $bVp2IntersectDIntr :: Location -> Type -> operand -> operand -> AbstractOperation operand
$mVp2IntersectDIntr :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> operand -> operand -> r)
-> (Void# -> r)
-> r
Vp2IntersectDIntr loc ty0 a_ b_  = Operation
          { opName = "x86vector.avx512.intr.vp2intersect.d.512"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [a_, b_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.intr.vp2intersect.d.512@.
avx512_intr_vp2intersect_d_512 :: () => MonadBlockBuilder m => Type -> Value -> Value -> m Value
avx512_intr_vp2intersect_d_512 :: Type -> Value -> Value -> m Value
avx512_intr_vp2intersect_d_512 Type
ty0 Value
a_ Value
b_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.intr.vp2intersect.d.512"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- * avx512.vp2intersect
-- $avx512.vp2intersect
-- 
-- The @vp2intersect@ op is an AVX512 specific op that can lower to the proper
-- LLVMAVX512 operation: @llvm.vp2intersect.d.512@ or
-- @llvm.vp2intersect.q.512@ depending on the type of MLIR vectors it is
-- applied to.
-- 
-- \#\#\#\# From the Intel Intrinsics Guide:
-- 
-- Compute intersection of packed integer vectors @a@ and @b@, and store
-- indication of match in the corresponding bit of two mask registers
-- specified by @k1@ and @k2@. A match in corresponding elements of @a@ and
-- @b@ is indicated by a set bit in the corresponding bit of the mask
-- registers.
--   

-- | A pattern for @x86vector.avx512.vp2intersect@.
pattern Vp2Intersect :: () => () => Location -> Type -> Type -> operand -> operand -> AbstractOperation operand
pattern $bVp2Intersect :: Location
-> Type -> Type -> operand -> operand -> AbstractOperation operand
$mVp2Intersect :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> Type -> operand -> operand -> r)
-> (Void# -> r)
-> r
Vp2Intersect loc ty0 ty1 a_ b_  = Operation
          { opName = "x86vector.avx512.vp2intersect"
          , opLocation = loc
          , opResultTypes = Explicit [ty0, ty1]
          , opOperands = [a_, b_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.vp2intersect@.
avx512_vp2intersect :: () => MonadBlockBuilder m => Type -> Type -> Value -> Value -> m [Value]
avx512_vp2intersect :: Type -> Type -> Value -> Value -> m [Value]
avx512_vp2intersect Type
ty0 Type
ty1 Value
a_ Value
b_   = do
  (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.vp2intersect"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0, Type
ty1]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))

-- | A pattern for @x86vector.avx512.intr.vp2intersect.q.512@.
pattern Vp2IntersectQIntr :: () => () => Location -> Type -> operand -> operand -> AbstractOperation operand
pattern $bVp2IntersectQIntr :: Location -> Type -> operand -> operand -> AbstractOperation operand
$mVp2IntersectQIntr :: forall r operand.
AbstractOperation operand
-> (Location -> Type -> operand -> operand -> r)
-> (Void# -> r)
-> r
Vp2IntersectQIntr loc ty0 a_ b_  = Operation
          { opName = "x86vector.avx512.intr.vp2intersect.q.512"
          , opLocation = loc
          , opResultTypes = Explicit [ty0]
          , opOperands = [a_, b_]
          , opRegions = []
          , opSuccessors = []
          , opAttributes = (NoAttrs)
          }

-- | A builder for @x86vector.avx512.intr.vp2intersect.q.512@.
avx512_intr_vp2intersect_q_512 :: () => MonadBlockBuilder m => Type -> Value -> Value -> m Value
avx512_intr_vp2intersect_q_512 :: Type -> Value -> Value -> m Value
avx512_intr_vp2intersect_q_512 Type
ty0 Value
a_ Value
b_   = do
  ([Value] -> Value) -> m [Value] -> m Value
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Control.Monad.liftM [Value] -> Value
forall a. [a] -> a
Prelude.head (Operation -> m [Value]
forall (m :: * -> *). MonadBlockBuilder m => Operation -> m [Value]
AST.emitOp (Operation :: forall operand.
Name
-> Location
-> ResultTypes
-> [operand]
-> [Region]
-> [Name]
-> Map Name Attribute
-> AbstractOperation operand
Operation
          { opName :: Name
opName = Name
"x86vector.avx512.intr.vp2intersect.q.512"
          , opLocation :: Location
opLocation = Location
UnknownLocation
          , opResultTypes :: ResultTypes
opResultTypes = [Type] -> ResultTypes
Explicit [Type
ty0]
          , opOperands :: [Name]
opOperands = [(Value -> Name
AST.operand Value
a_), (Value -> Name
AST.operand Value
b_)]
          , opRegions :: [Region]
opRegions = []
          , opSuccessors :: [Name]
opSuccessors = []
          , opAttributes :: Map Name Attribute
opAttributes = (Map Name Attribute
NoAttrs)
          }))