diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,31 @@ +Copyright (c) 2019, Henning Thielemann + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * The names of contributors may not be used to endorse or promote + products derived from this software without specific prior + written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/Makefile b/Makefile new file mode 100644 --- /dev/null +++ b/Makefile @@ -0,0 +1,13 @@ +ghci: + ghci -Wall -i:src:x86/none src/Run.hs + +ghci-cpuid: + ghci -Wall -i:src:x86/cpuid src/Run.hs + +testbuild: + runhaskell Setup.lhs configure --user -fbuildTools -fcpuid + runhaskell Setup.lhs build + runhaskell Setup.lhs haddock + + runhaskell Setup.lhs configure --user -f-cpuid + runhaskell Setup.lhs build diff --git a/Setup.lhs b/Setup.lhs new file mode 100644 --- /dev/null +++ b/Setup.lhs @@ -0,0 +1,3 @@ +#! /usr/bin/env runhaskell +> import Distribution.Simple +> main = defaultMain diff --git a/llvm-extension.cabal b/llvm-extension.cabal new file mode 100644 --- /dev/null +++ b/llvm-extension.cabal @@ -0,0 +1,101 @@ +Cabal-Version: 2.2 +Name: llvm-extension +Version: 0.0 +License: BSD-3-Clause +License-File: LICENSE +Author: Henning Thielemann +Maintainer: Henning Thielemann +Homepage: https://wiki.haskell.org/LLVM +Category: Compilers/Interpreters, Code Generation +Synopsis: Processor specific intrinsics for the llvm interface +Description: + The Low-Level Virtual-Machine is a compiler back-end with optimizer. + You may also call it a high-level portable assembler. + LLVM provides processor specific instructions via so-called intrinsics. + This package allows you to use such instructions, + while also defining fallbacks for older versions of a processor + and different architectures. + . + We provide an auto-generated list of intrinsics + for special SSE+AVX instructions on the X86 target. + On x86 architectures we depend on the cpuid package + for automatic detection of available features. + This works when using JIT or native compilation, + but it fails for cross-compilation. + . + Formerly, this package was part of the @llvm-extra@ package. + But the names of intrinsics change between LLVM versions without notification. + Intrinsics for processor specific instructions are considered a last resort. + In current LLVM versions all functions I needed so far + are available as generic intrinsics. +Stability: Experimental +Tested-With: GHC==7.4.2, GHC==7.8.4 +Tested-With: GHC==8.4.4, GHC==8.6.5, GHC==8.8.1 +Build-Type: Simple +Extra-Source-Files: + Makefile + +Flag buildTools + description: Build intrinsic translator + default: False + +Flag cpuid + description: Use CPUID for host feature detection if available on the architecture + default: True + +Source-Repository this + Tag: 0.0 + Type: darcs + Location: http://hub.darcs.net/thielema/llvm-extension/ + +Source-Repository head + Type: darcs + Location: http://hub.darcs.net/thielema/llvm-extension/ + +Library + Build-Depends: + llvm-extra >=0.9 && <0.10, + llvm-tf >=9.0 && <9.1, + tfp >=1.0 && <1.1, + non-empty >=0.2.1 && <0.4, + containers >=0.1 && <0.7, + transformers >=0.1.1 && <0.6, + utility-ht >=0.0.11 && <0.1, + prelude-compat >=0.0 && <0.0.1, + base >=3 && <5 + + If (arch(i386) || arch(x86_64)) && flag(cpuid) + Build-Depends: + unsafe >=0.0 && <0.1, + cpuid >=0.2.3 && <0.3 + Hs-Source-Dirs: x86/cpuid + Else + -- Instead of calling the cpuid instruction directly + -- we may ask LLVM's Subtarget detection. + -- This would also enable cross compilation. + -- However in LLVM-2.6 this is only available in the C++ interface. + Hs-Source-Dirs: x86/none + + Default-Language: Haskell98 + GHC-Options: -Wall + Hs-source-dirs: src + Exposed-Modules: + LLVM.Extra.Extension + LLVM.Extra.Extension.X86 + LLVM.Extra.ExtensionCheck.X86 + Other-Modules: + LLVM.Extra.Extension.X86Auto + +Executable prepare-intrinsics + If flag(buildTools) + Build-Depends: + parsec >=2.1 && <3.2, + containers >=0.1 && <0.7, + transformers, + utility-ht >=0.0.1 && <0.1, + base >=3 && <5 + Else + Buildable: False + Default-Language: Haskell98 + GHC-Options: -Wall + Main-Is: src/PrepareIntrinsics.hs diff --git a/src/LLVM/Extra/Extension.hs b/src/LLVM/Extra/Extension.hs new file mode 100644 --- /dev/null +++ b/src/LLVM/Extra/Extension.hs @@ -0,0 +1,178 @@ +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Rank2Types #-} +module LLVM.Extra.Extension ( + T, Result, CallArgs, + Subtarget(Subtarget), wrap, + intrinsic, intrinsicAttr, + run, runWhen, runUnsafe, + with, with2, with3, + ) where + +import qualified LLVM.Core as LLVM +import LLVM.Core + (Value, CodeGenFunction, externFunction, call, + addAttributes, Attribute {- (ReadNoneAttribute) -}, ) + +import Data.Map (Map, ) +import qualified Data.Map as Map + +import Control.Monad.Trans.Writer (Writer, writer, runWriter, ) +import Control.Monad (join, ) +import Control.Applicative (Applicative, pure, (<*>), ) + +import Prelude2010 hiding (replicate, sum, map, zipWith, ) +import Prelude () + + +data Subtarget = + Subtarget { + targetName, name :: String, + check :: forall r. CodeGenFunction r Bool + } + + +{- | +This is an Applicative functor that registers, +what extensions are needed in order to run the contained instructions. +You can escape from the functor by calling 'run' +and providing a generic implementation. + +We use an applicative functor +since with a monadic interface +we had to create the specialised code in every case, +in order to see which extensions where used +in the course of creating the instructions. + +We use only one (unparameterized) type for all extensions, +since this is the most simple solution. +Alternatively we could use a type parameter +where class constraints show what extensions are needed. +This would be just like exceptions that are explicit in the type signature +as in the control-monad-exception package. +However we would still need to lift all basic LLVM instructions to the new monad. +-} +newtype T a = + Cons (Writer (Map String Subtarget) a) + deriving (Functor, Applicative) + +{- | +Declare that a certain plain LLVM instruction +depends on a particular extension. +This can be useful if you rely on the data layout +of a certain architecture when doing a bitcast, +or if you know that LLVM translates a certain generic operation +to something especially optimal for the declared extension. +-} +wrap :: Subtarget -> a -> T a +wrap tar cgf = + Cons $ + writer (cgf, Map.singleton (name tar) tar) + + +type family Result g :: * +type instance Result (a -> g) = Result g +type instance Result (CodeGenFunction r a) = r + + +{- | Analogous to 'LLVM.FunctionArgs' + +The type parameter @r@ and its functional dependency are necessary +since @g@ must be a function of the form @a -> ... -> c -> CodeGenFunction r d@ +and we must ensure that the explicit @r@ and the implicit @r@ in the @g@ do match. +-} +class CallArgs g where + buildIntrinsic :: [Attribute] -> CodeGenFunction (Result g) g -> g + +instance (CallArgs g) => + CallArgs (Value a -> g) where + buildIntrinsic attrs g x = + buildIntrinsic attrs (fmap ($x) g) + +instance CallArgs (CodeGenFunction r (Value a)) where + buildIntrinsic attrs g = do + z <- join g + addAttributes z LLVM.attributeReturnIndex attrs + return z + +{- | +Create an intrinsic and register the needed extension. +We cannot immediately check whether the signature matches +or whether the right extension is given. +However, when resolving intrinsics +LLVM will not find the intrinsic if the extension is wrong, +and it also checks the signature. +-} +intrinsic :: + (LLVM.IsFunction f, LLVM.CallArgs f g (Result g), CallArgs g) => + Subtarget -> String -> T g +intrinsic = + intrinsicAttr [{- ReadNoneAttribute -}] + +intrinsicAttr :: + (LLVM.IsFunction f, LLVM.CallArgs f g (Result g), CallArgs g) => + [Attribute] -> Subtarget -> String -> T g +intrinsicAttr attrs tar intr = + wrap tar $ + buildIntrinsic attrs $ + fmap call $ + externFunction $ + "llvm." ++ targetName tar ++ "." ++ name tar ++ "." ++ intr + + +infixl 1 `run` + +{- | +@run generic specific@ generates the @specific@ code +if the required extensions are available on the host processor +and @generic@ otherwise. +-} +run :: + CodeGenFunction r a -> + T (CodeGenFunction r a) -> + CodeGenFunction r a +run alt (Cons m) = do + let (a,s) = runWriter m + b <- mapM check (Map.elems s) + if and b + then a + else alt + +{- | +Convenient variant of 'run': +Only run the code with extended instructions +if an additional condition is satisfied. +-} +runWhen :: + Bool -> + CodeGenFunction r a -> + T (CodeGenFunction r a) -> + CodeGenFunction r a +runWhen c alt (Cons m) = do + let (a,s) = runWriter m + b <- mapM check (Map.elems s) + if c && and b + then a + else alt + +{- | +Only for debugging purposes. +-} +runUnsafe :: + T a -> a +runUnsafe (Cons m) = + fst $ runWriter m + + +with :: (Functor f) => f a -> (a -> b) -> f b +with = flip fmap + +with2 :: (Applicative f) => f a -> f b -> (a -> b -> c) -> f c +with2 a b f = + pure f <*> a <*> b + +with3 :: (Applicative f) => f a -> f b -> f c -> (a -> b -> c -> d) -> f d +with3 a b c f = + pure f <*> a <*> b <*> c diff --git a/src/LLVM/Extra/Extension/X86.hs b/src/LLVM/Extra/Extension/X86.hs new file mode 100644 --- /dev/null +++ b/src/LLVM/Extra/Extension/X86.hs @@ -0,0 +1,368 @@ +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE FlexibleContexts #-} +{- | +Some special operations on X86 processors. +If you want to use them in algorithms +you will always have to prepare an alternative implementation +in terms of plain LLVM instructions. +You will then run them with 'Ext.run' +and this driver function then selects the most advanced of both implementations. +Functions that are written this way can be found in "LLVM.Extra.Vector". +Availability of extensions is checked with the @CPUID@ instruction. +However this does only work if you compile code for the host machine, +that is cross compilation will fail! +For cross compilation we would need access to the SubTarget detection of LLVM +that is only available in the C++ interface in version 2.6. +-} +module LLVM.Extra.Extension.X86 ( + X86.maxss, X86.minss, X86.maxps, X86.minps, + X86.maxsd, X86.minsd, X86.maxpd, X86.minpd, + cmpss, cmpps, cmpsd, cmppd, cmpps256, cmppd256, + pcmpgtb, pcmpgtw, pcmpgtd, pcmpgtq, + pcmpugtb, pcmpugtw, pcmpugtd, pcmpugtq, + pminsb, pminsw, pminsd, + pmaxsb, pmaxsw, pmaxsd, + pminub, pminuw, pminud, + pmaxub, pmaxuw, pmaxud, + pabsb, pabsw, pabsd, + pmuludq, pmuldq, + pmulld, + cvtps2dq, cvtpd2dq, + cvtdq2ps, cvtdq2pd, + ldmxcsr, stmxcsr, withMXCSR, + X86.haddps, X86.haddpd, X86.dpps, X86.dppd, + roundss, X86.roundps, roundsd, X86.roundpd, + absss, abssd, absps, abspd, + X86.psllw128, X86.pslld128, X86.psllq128, + X86.psrlw128, X86.psrld128, X86.psrlq128, + X86.psraw128, X86.psrad128, + X86.paddsb128, X86.paddsw128, X86.paddusb128, X86.paddusw128, + X86.psubsb128, X86.psubsw128, X86.psubusb128, X86.psubusw128, + ) where + +import qualified LLVM.Extra.Extension.X86Auto as X86 +import qualified LLVM.Extra.Extension as Ext +import LLVM.Extra.Extension.X86Auto ( + V2Double, V4Float, + V2Int64, V2Word64, + V4Int32, V4Word32, + V8Int16, V8Word16, + V16Int8, V16Word8, + ) +import LLVM.Extra.ExtensionCheck.X86 + (sse1, sse2, sse41, sse42, ) + +import qualified LLVM.Extra.Arithmetic as A +import qualified LLVM.Core.Guided as Guided +import qualified LLVM.Core as LLVM +import LLVM.Core + (Value, Vector, valueOf, constOf, vector, + CodeGenFunction, FPPredicate, ) + +import qualified Type.Data.Num.Decimal as TypeNum + +import qualified Data.NonEmpty.Class as NonEmptyC +import qualified Data.Empty as Empty +import Data.NonEmpty ((!:), ) + +import Data.Bits (clearBit, complement, ) +import Data.Word (Word8, Word32, Word64, ) + +import qualified Control.Monad.HT as M +import Control.Monad.HT ((<=<), ) +import Control.Applicative (pure, ) + +import Foreign.Ptr (Ptr, ) + +import Prelude2010 +import Prelude () + + +switchFPPred :: + (Num i, LLVM.IsConst i, LLVM.IsInteger i, LLVM.IsPrimitive i, + LLVM.IsFirstClass v, + TypeNum.Positive n, + LLVM.IsSized v, LLVM.IsSized (Vector n i), + LLVM.SizeOf v ~ LLVM.SizeOf (Vector n i)) => + (Value v -> Value v -> Value Word8 -> CodeGenFunction r (Value v)) -> + FPPredicate -> Value v -> Value v -> CodeGenFunction r (Value (Vector n i)) +switchFPPred g p x y = + let f i x0 y0 = LLVM.bitcast =<< g x0 y0 (valueOf i) + in case p of + LLVM.FPFalse -> return $ LLVM.value LLVM.zero + LLVM.FPOEQ -> f 0 x y + LLVM.FPOGT -> f 1 y x + LLVM.FPOGE -> f 2 y x + LLVM.FPOLT -> f 1 x y + LLVM.FPOLE -> f 2 x y + LLVM.FPONE -> M.liftJoin2 A.and (f 7 x y) (f 4 x y) + LLVM.FPORD -> f 7 x y + LLVM.FPUNO -> f 3 x y + LLVM.FPUEQ -> M.liftJoin2 A.or (f 3 x y) (f 0 x y) + LLVM.FPUGT -> f 6 x y + LLVM.FPUGE -> f 5 x y + LLVM.FPULT -> f 6 y x + LLVM.FPULE -> f 5 y x + LLVM.FPUNE -> f 4 x y + LLVM.FPTrue -> return $ valueOf $ pure (-1) + +cmpss :: Ext.T (FPPredicate -> V4Float -> V4Float -> CodeGenFunction r V4Int32) +cmpss = fmap switchFPPred X86.cmpss + +cmpps :: Ext.T (FPPredicate -> V4Float -> V4Float -> CodeGenFunction r V4Int32) +cmpps = fmap switchFPPred X86.cmpps + +cmpsd :: Ext.T (FPPredicate -> V2Double -> V2Double -> CodeGenFunction r V2Int64) +cmpsd = fmap switchFPPred X86.cmpsd + +cmppd :: Ext.T (FPPredicate -> V2Double -> V2Double -> CodeGenFunction r V2Int64) +cmppd = fmap switchFPPred X86.cmppd + +cmpps256 :: Ext.T (FPPredicate -> X86.V8Float -> X86.V8Float -> CodeGenFunction r X86.V8Int32) +cmpps256 = fmap switchFPPred X86.cmpps256 + +cmppd256 :: Ext.T (FPPredicate -> X86.V4Double -> X86.V4Double -> CodeGenFunction r X86.V4Int64) +cmppd256 = fmap switchFPPred X86.cmppd256 + + +pcmpgtb :: Ext.T (V16Int8 -> V16Int8 -> CodeGenFunction r V16Int8) +pcmpgtb = Ext.intrinsic sse2 "pcmpgt.b" + +pcmpgtw :: Ext.T (V8Int16 -> V8Int16 -> CodeGenFunction r V8Int16) +pcmpgtw = Ext.intrinsic sse2 "pcmpgt.w" + +pcmpgtd :: Ext.T (V4Int32 -> V4Int32 -> CodeGenFunction r V4Int32) +pcmpgtd = Ext.intrinsic sse2 "pcmpgt.d" + +pcmpgtq :: Ext.T (V2Int64 -> V2Int64 -> CodeGenFunction r V2Int64) +pcmpgtq = Ext.intrinsic sse42 "pcmpgtq" + + +pcmpuFromPcmp :: + (TypeNum.Positive n, + LLVM.IsPrimitive s, + LLVM.IsPrimitive u, LLVM.IsArithmetic u, LLVM.IsConst u, + Bounded u, Integral u, + LLVM.IsSized (Vector n s), LLVM.IsSized (Vector n u), + LLVM.SizeOf (Vector n s) ~ LLVM.SizeOf (Vector n u)) => + Ext.T (Value (Vector n s) -> Value (Vector n s) -> CodeGenFunction r (Value (Vector n s))) -> + Ext.T (Value (Vector n u) -> Value (Vector n u) -> CodeGenFunction r (Value (Vector n u))) +pcmpuFromPcmp pcmp = + Ext.with pcmp $ \cmp x y -> do + let offset = valueOf $ pure (1 + div maxBound 2) + xa <- LLVM.bitcast =<< A.sub x offset + ya <- LLVM.bitcast =<< A.sub y offset + LLVM.bitcast =<< cmp xa ya + +pcmpugtb :: Ext.T (V16Word8 -> V16Word8 -> CodeGenFunction r V16Word8) +pcmpugtb = pcmpuFromPcmp pcmpgtb + +pcmpugtw :: Ext.T (V8Word16 -> V8Word16 -> CodeGenFunction r V8Word16) +pcmpugtw = pcmpuFromPcmp pcmpgtw + +pcmpugtd :: Ext.T (V4Word32 -> V4Word32 -> CodeGenFunction r V4Word32) +pcmpugtd = pcmpuFromPcmp pcmpgtd + +pcmpugtq :: Ext.T (V2Word64 -> V2Word64 -> CodeGenFunction r V2Word64) +pcmpugtq = pcmpuFromPcmp pcmpgtq + + +pminsb, pmaxsb :: Ext.T (V16Int8 -> V16Int8 -> CodeGenFunction r V16Int8) +pminsb = X86.pminsb128 +pmaxsb = X86.pmaxsb128 + +pminsw, pmaxsw :: Ext.T (V8Int16 -> V8Int16 -> CodeGenFunction r V8Int16) +pminsw = X86.pminsw128 +pmaxsw = X86.pmaxsw128 + +pminsd, pmaxsd :: Ext.T (V4Int32 -> V4Int32 -> CodeGenFunction r V4Int32) +pminsd = X86.pminsd128 +pmaxsd = X86.pmaxsd128 + + +pminub, pmaxub :: Ext.T (V16Word8 -> V16Word8 -> CodeGenFunction r V16Word8) +pminub = X86.pminub128 +pmaxub = X86.pmaxub128 + +pminuw, pmaxuw :: Ext.T (V8Word16 -> V8Word16 -> CodeGenFunction r V8Word16) +pminuw = X86.pminuw128 +pmaxuw = X86.pmaxuw128 + +pminud, pmaxud :: Ext.T (V4Word32 -> V4Word32 -> CodeGenFunction r V4Word32) +pminud = X86.pminud128 +pmaxud = X86.pmaxud128 + + +pabsb :: Ext.T (V16Int8 -> CodeGenFunction r V16Int8) +pabsb = X86.pabsb128 + +pabsw :: Ext.T (V8Int16 -> CodeGenFunction r V8Int16) +pabsw = X86.pabsw128 + +pabsd :: Ext.T (V4Int32 -> CodeGenFunction r V4Int32) +pabsd = X86.pabsd128 + + +pmuludq :: Ext.T (V4Word32 -> V4Word32 -> CodeGenFunction r V2Word64) +pmuludq = X86.pmuludq128 + +pmuldq :: Ext.T (V4Int32 -> V4Int32 -> CodeGenFunction r V2Int64) +pmuldq = X86.pmuldq128 + +pmulld :: Ext.T (V4Word32 -> V4Word32 -> CodeGenFunction r V4Word32) +pmulld = Ext.wrap sse41 LLVM.mul +-- pmulld = Ext.intrinsic sse41 "pmulld" + + +cvtps2dq :: Ext.T (V4Float -> CodeGenFunction r V4Int32) +cvtps2dq = X86.cvtps2dq + +-- | the upper two integers are set to zero, there is no instruction that converts to Int64 +cvtpd2dq :: Ext.T (V2Double -> CodeGenFunction r V4Int32) +cvtpd2dq = X86.cvtpd2dq + + +cvtdq2ps :: Ext.T (V4Int32 -> CodeGenFunction r V4Float) +cvtdq2ps = X86.cvtdq2ps + +-- | the upper two integers are ignored, there is no instruction that converts from Int64 +cvtdq2pd :: Ext.T (V4Int32 -> CodeGenFunction r V2Double) +cvtdq2pd = X86.cvtdq2pd + + +valueUnit :: Value () -> () +valueUnit _ = () + +{- | +MXCSR is not really supported by LLVM-2.6. +LLVM does not know about the dependency of all floating point operations +on this status register. +-} +ldmxcsr :: Ext.T (Value (Ptr Word32) -> CodeGenFunction r ()) +ldmxcsr = + fmap (fmap valueUnit .) $ Ext.intrinsicAttr [] sse1 "ldmxcsr" + +stmxcsr :: Ext.T (Value (Ptr Word32) -> CodeGenFunction r ()) +stmxcsr = + fmap (fmap valueUnit .) $ Ext.intrinsicAttr [] sse1 "stmxcsr" + +withMXCSR :: Word32 -> Ext.T (CodeGenFunction r a -> CodeGenFunction r a) +withMXCSR mxcsr = + Ext.with2 ldmxcsr stmxcsr $ \ ld st f -> do + mxcsrOld <- LLVM.alloca + st mxcsrOld + mxcsrFloor <- LLVM.alloca + LLVM.store (valueOf $ mxcsr) mxcsrFloor +{- unfortunately, createGlobal is a function CodeGenModule monad + mxcsrFloor <- + LLVM.createGlobal True LLVM.InternalLinkage mxcsr +-} + ld mxcsrFloor + r <- f + ld mxcsrOld + return r + +{- +[maxsd, minsd, maxpd, minpd] = + map (Ext.intrinsic sse2) + ["max.ss", "min.ss", "max.ps", "min.ps"] +-} + +roundss :: Ext.T (V4Float -> Value Word32 -> CodeGenFunction r V4Float) +roundss = + fmap (\f -> f (LLVM.value LLVM.undef)) X86.roundss + +roundsd :: Ext.T (V2Double -> Value Word32 -> CodeGenFunction r V2Double) +roundsd = + fmap (\f -> f (LLVM.value LLVM.undef)) X86.roundsd + + + +{- +Not an LLVM intrinsic but implementation specific: +We expect that floating point values are in IEEE format +and thus the most significant bit is the sign. +The absolute value can be computed very efficiently by clearing the sign bit. +Actually, LLVM's codegen implements neg by an XOR on the sign bit. +-} +absss :: Ext.T (V4Float -> CodeGenFunction r V4Float) +absss = + Ext.wrap sse1 $ + LLVM.bitcast + <=< A.and (LLVM.valueOf $ vector $ + (flip clearBit 31 $ complement 0) !: NonEmptyC.repeat (complement 0) + :: V4Word32) + <=< LLVM.bitcast + +{- +This function works on a single Float, +but I like to do the masking in an XMM register +because usually the value is there anyway. + +absss = + flip LLVM.extractelement (valueOf 0) + . flip asTypeOf (undefined :: V4Float) + <=< LLVM.bitcast +-- <=< A.and (LLVM.value $ constVector [constOf 0x7FFFFFFF] :: V4Word32) +-- <=< A.and (LLVM.value $ constVector [constOf 0x7FFFFFFF, LLVM.undef, LLVM.undef, LLVM.undef] :: V4Word32) + <=< A.and (LLVM.value $ constVector [constOf 0x7FFFFFFF, LLVM.zero, LLVM.zero, LLVM.zero] :: V4Word32) + <=< LLVM.bitcast + . flip asTypeOf (undefined :: V4Float) + <=< flip (LLVM.insertelement (LLVM.value LLVM.undef)) (valueOf 0) +-} +{- This moves the value to a general purpose register and performs the bit masking there +absss = + LLVM.bitcast + <=< A.and (valueOf 0x7FFFFFFF :: Value Word32) + <=< LLVM.bitcast +-} + +abssd :: Ext.T (V2Double -> CodeGenFunction r V2Double) +abssd = + Ext.wrap sse2 $ + LLVM.bitcast + <=< A.and (LLVM.valueOf $ vector $ + (flip clearBit 63 $ complement 0) !: complement 0 !: Empty.Cons + :: V2Word64) + <=< LLVM.bitcast + + +mask :: + (TypeNum.Positive n, LLVM.IsConst w, LLVM.IsPrimitive w, LLVM.IsInteger w) => + w -> Value (Vector n w) -> CodeGenFunction r (Value (Vector n w)) +mask x = + A.and (LLVM.valueOf $ pure x) + +absps :: + (TypeNum.Positive n) => + Ext.T (Value (Vector n Float) -> CodeGenFunction r (Value (Vector n Float))) +absps = + Ext.wrap sse1 $ + Guided.bitcast Guided.vector + <=< mask (flip clearBit 31 $ complement 0 :: Word32) + <=< Guided.bitcast Guided.vector + +abspd :: + (TypeNum.Positive n) => + Ext.T (Value (Vector n Double) -> CodeGenFunction r (Value (Vector n Double))) +abspd = + Ext.wrap sse2 $ + Guided.bitcast Guided.vector + <=< mask (flip clearBit 63 $ complement 0 :: Word64) + <=< Guided.bitcast Guided.vector + +{- | +cumulative sum: +@(a,b,c,d) -> (a,a+b,a+b+c,a+b+c+d)@ + +I try to cleverly use horizontal add, +but the generic version in the Vector module is better. +-} +_cumulate1s :: Ext.T (V4Float -> CodeGenFunction r V4Float) +_cumulate1s = Ext.with X86.haddps $ \haddp x -> do + y <- haddp x (LLVM.value LLVM.undef) + z <- LLVM.shufflevector x y $ + constOf $ vector $ 0!:4!:2!:5!:Empty.Cons + offset <- LLVM.shufflevector y (LLVM.value LLVM.zero) $ + constOf $ vector $ 4!:5!:0!:0!:Empty.Cons + A.add z offset diff --git a/src/LLVM/Extra/Extension/X86Auto.hs b/src/LLVM/Extra/Extension/X86Auto.hs new file mode 100644 --- /dev/null +++ b/src/LLVM/Extra/Extension/X86Auto.hs @@ -0,0 +1,2699 @@ +{- Do not edit! This file was created with the PrepareIntrinsics tool. -} +module LLVM.Extra.Extension.X86Auto where + +import qualified LLVM.Extra.Extension as Ext +import qualified LLVM.Extra.ExtensionCheck.X86 as ExtX86 +import qualified LLVM.Core as LLVM +import qualified Type.Data.Num.Decimal as TypeNum +import qualified Data.Int as I +import qualified Data.Word as W +import Foreign.Ptr (Ptr, ) + +type MMX = LLVM.Value (LLVM.Vector TypeNum.D8 W.Word8) +type V16Float = LLVM.Value (LLVM.Vector TypeNum.D16 Float) +type V16Int16 = LLVM.Value (LLVM.Vector TypeNum.D16 I.Int16) +type V16Int32 = LLVM.Value (LLVM.Vector TypeNum.D16 I.Int32) +type V16Int8 = LLVM.Value (LLVM.Vector TypeNum.D16 I.Int8) +type V16Word16 = LLVM.Value (LLVM.Vector TypeNum.D16 W.Word16) +type V16Word8 = LLVM.Value (LLVM.Vector TypeNum.D16 W.Word8) +type V2Double = LLVM.Value (LLVM.Vector TypeNum.D2 Double) +type V2Int64 = LLVM.Value (LLVM.Vector TypeNum.D2 I.Int64) +type V2Word64 = LLVM.Value (LLVM.Vector TypeNum.D2 W.Word64) +type V32Int16 = LLVM.Value (LLVM.Vector TypeNum.D32 I.Int16) +type V32Int8 = LLVM.Value (LLVM.Vector TypeNum.D32 I.Int8) +type V32Word8 = LLVM.Value (LLVM.Vector TypeNum.D32 W.Word8) +type V4Double = LLVM.Value (LLVM.Vector TypeNum.D4 Double) +type V4Float = LLVM.Value (LLVM.Vector TypeNum.D4 Float) +type V4Int32 = LLVM.Value (LLVM.Vector TypeNum.D4 I.Int32) +type V4Int64 = LLVM.Value (LLVM.Vector TypeNum.D4 I.Int64) +type V4Word32 = LLVM.Value (LLVM.Vector TypeNum.D4 W.Word32) +type V4Word64 = LLVM.Value (LLVM.Vector TypeNum.D4 W.Word64) +type V64Int8 = LLVM.Value (LLVM.Vector TypeNum.D64 I.Int8) +type V8Double = LLVM.Value (LLVM.Vector TypeNum.D8 Double) +type V8Float = LLVM.Value (LLVM.Vector TypeNum.D8 Float) +type V8Int16 = LLVM.Value (LLVM.Vector TypeNum.D8 I.Int16) +type V8Int32 = LLVM.Value (LLVM.Vector TypeNum.D8 I.Int32) +type V8Int64 = LLVM.Value (LLVM.Vector TypeNum.D8 I.Int64) +type V8Word16 = LLVM.Value (LLVM.Vector TypeNum.D8 W.Word16) +type V8Word32 = LLVM.Value (LLVM.Vector TypeNum.D8 W.Word32) + +{- +readeflags_u32 :: Ext.T (LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +readeflags_u32 = Ext.intrinsic ExtX86.flags "read.u32" + +readeflags_u64 :: Ext.T (LLVM.CodeGenFunction r (LLVM.Value I.Int64)) +readeflags_u64 = Ext.intrinsic ExtX86.flags "read.u64" + +writeeflags_u32 :: Ext.T (LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (LLVM.Value ())) +writeeflags_u32 = Ext.intrinsic ExtX86.flags "write.u32" + +writeeflags_u64 :: Ext.T (LLVM.Value I.Int64 -> LLVM.CodeGenFunction r (LLVM.Value ())) +writeeflags_u64 = Ext.intrinsic ExtX86.flags "write.u64" + +rdtsc :: Ext.T (LLVM.CodeGenFunction r (LLVM.Value I.Int64)) +rdtsc = Ext.intrinsic ExtX86. "int.x86.rdtsc" + +rdtscp :: Ext.T (LLVM.Value (Ptr ()) -> LLVM.CodeGenFunction r (LLVM.Value I.Int64)) +rdtscp = Ext.intrinsic ExtX86. "int.x86.rdtscp" + +rdpmc :: Ext.T (LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (LLVM.Value I.Int64)) +rdpmc = Ext.intrinsic ExtX86. "int.x86.rdpmc" +-} + +pavgusb :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pavgusb = Ext.intrinsic ExtX86.amd3dnow "pavgusb" + +pf2id :: Ext.T (MMX -> LLVM.CodeGenFunction r (MMX)) +pf2id = Ext.intrinsic ExtX86.amd3dnow "pf2id" + +pfacc :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfacc = Ext.intrinsic ExtX86.amd3dnow "pfacc" + +pfadd :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfadd = Ext.intrinsic ExtX86.amd3dnow "pfadd" + +pfcmpeq :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfcmpeq = Ext.intrinsic ExtX86.amd3dnow "pfcmpeq" + +pfcmpge :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfcmpge = Ext.intrinsic ExtX86.amd3dnow "pfcmpge" + +pfcmpgt :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfcmpgt = Ext.intrinsic ExtX86.amd3dnow "pfcmpgt" + +pfmax :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfmax = Ext.intrinsic ExtX86.amd3dnow "pfmax" + +pfmin :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfmin = Ext.intrinsic ExtX86.amd3dnow "pfmin" + +pfmul :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfmul = Ext.intrinsic ExtX86.amd3dnow "pfmul" + +pfrcp :: Ext.T (MMX -> LLVM.CodeGenFunction r (MMX)) +pfrcp = Ext.intrinsic ExtX86.amd3dnow "pfrcp" + +pfrcpit1 :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfrcpit1 = Ext.intrinsic ExtX86.amd3dnow "pfrcpit1" + +pfrcpit2 :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfrcpit2 = Ext.intrinsic ExtX86.amd3dnow "pfrcpit2" + +pfrsqrt :: Ext.T (MMX -> LLVM.CodeGenFunction r (MMX)) +pfrsqrt = Ext.intrinsic ExtX86.amd3dnow "pfrsqrt" + +pfrsqit1 :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfrsqit1 = Ext.intrinsic ExtX86.amd3dnow "pfrsqit1" + +pfsub :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfsub = Ext.intrinsic ExtX86.amd3dnow "pfsub" + +pfsubr :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfsubr = Ext.intrinsic ExtX86.amd3dnow "pfsubr" + +pi2fd :: Ext.T (MMX -> LLVM.CodeGenFunction r (MMX)) +pi2fd = Ext.intrinsic ExtX86.amd3dnow "pi2fd" + +pmulhrw :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pmulhrw = Ext.intrinsic ExtX86.amd3dnow "pmulhrw" + +pf2iw :: Ext.T (MMX -> LLVM.CodeGenFunction r (MMX)) +pf2iw = Ext.intrinsic ExtX86.amd3dnowa "pf2iw" + +pfnacc :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfnacc = Ext.intrinsic ExtX86.amd3dnowa "pfnacc" + +pfpnacc :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pfpnacc = Ext.intrinsic ExtX86.amd3dnowa "pfpnacc" + +pi2fw :: Ext.T (MMX -> LLVM.CodeGenFunction r (MMX)) +pi2fw = Ext.intrinsic ExtX86.amd3dnowa "pi2fw" + +addss :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +addss = Ext.intrinsic ExtX86.sse1 "add.ss" + +subss :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +subss = Ext.intrinsic ExtX86.sse1 "sub.ss" + +mulss :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +mulss = Ext.intrinsic ExtX86.sse1 "mul.ss" + +divss :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +divss = Ext.intrinsic ExtX86.sse1 "div.ss" + +sqrtss :: Ext.T (V4Float -> LLVM.CodeGenFunction r (V4Float)) +sqrtss = Ext.intrinsic ExtX86.sse1 "sqrt.ss" + +sqrtps :: Ext.T (V4Float -> LLVM.CodeGenFunction r (V4Float)) +sqrtps = Ext.intrinsic ExtX86.sse1 "sqrt.ps" + +rcpss :: Ext.T (V4Float -> LLVM.CodeGenFunction r (V4Float)) +rcpss = Ext.intrinsic ExtX86.sse1 "rcp.ss" + +rcpps :: Ext.T (V4Float -> LLVM.CodeGenFunction r (V4Float)) +rcpps = Ext.intrinsic ExtX86.sse1 "rcp.ps" + +rsqrtss :: Ext.T (V4Float -> LLVM.CodeGenFunction r (V4Float)) +rsqrtss = Ext.intrinsic ExtX86.sse1 "rsqrt.ss" + +rsqrtps :: Ext.T (V4Float -> LLVM.CodeGenFunction r (V4Float)) +rsqrtps = Ext.intrinsic ExtX86.sse1 "rsqrt.ps" + +minss :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +minss = Ext.intrinsic ExtX86.sse1 "min.ss" + +minps :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +minps = Ext.intrinsic ExtX86.sse1 "min.ps" + +maxss :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +maxss = Ext.intrinsic ExtX86.sse1 "max.ss" + +maxps :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +maxps = Ext.intrinsic ExtX86.sse1 "max.ps" + +cmpss :: Ext.T (V4Float -> V4Float -> LLVM.Value W.Word8 -> LLVM.CodeGenFunction r (V4Float)) +cmpss = Ext.intrinsic ExtX86.sse1 "cmp.ss" + +cmpps :: Ext.T (V4Float -> V4Float -> LLVM.Value W.Word8 -> LLVM.CodeGenFunction r (V4Float)) +cmpps = Ext.intrinsic ExtX86.sse1 "cmp.ps" + +comieq :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comieq = Ext.intrinsic ExtX86.sse1 "comieq.ss" + +comilt :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comilt = Ext.intrinsic ExtX86.sse1 "comilt.ss" + +comile :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comile = Ext.intrinsic ExtX86.sse1 "comile.ss" + +comigt :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comigt = Ext.intrinsic ExtX86.sse1 "comigt.ss" + +comige :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comige = Ext.intrinsic ExtX86.sse1 "comige.ss" + +comineq :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comineq = Ext.intrinsic ExtX86.sse1 "comineq.ss" + +ucomieq :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomieq = Ext.intrinsic ExtX86.sse1 "ucomieq.ss" + +ucomilt :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomilt = Ext.intrinsic ExtX86.sse1 "ucomilt.ss" + +ucomile :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomile = Ext.intrinsic ExtX86.sse1 "ucomile.ss" + +ucomigt :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomigt = Ext.intrinsic ExtX86.sse1 "ucomigt.ss" + +ucomige :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomige = Ext.intrinsic ExtX86.sse1 "ucomige.ss" + +ucomineq :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomineq = Ext.intrinsic ExtX86.sse1 "ucomineq.ss" + +cvtss2si :: Ext.T (V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +cvtss2si = Ext.intrinsic ExtX86.sse1 "cvtss2si" + +cvtss2si64 :: Ext.T (V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int64)) +cvtss2si64 = Ext.intrinsic ExtX86.sse1 "cvtss2si64" + +cvttss2si :: Ext.T (V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +cvttss2si = Ext.intrinsic ExtX86.sse1 "cvttss2si" + +cvttss2si64 :: Ext.T (V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int64)) +cvttss2si64 = Ext.intrinsic ExtX86.sse1 "cvttss2si64" + +cvtsi2ss :: Ext.T (V4Float -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V4Float)) +cvtsi2ss = Ext.intrinsic ExtX86.sse1 "cvtsi2ss" + +cvtsi642ss :: Ext.T (V4Float -> LLVM.Value I.Int64 -> LLVM.CodeGenFunction r (V4Float)) +cvtsi642ss = Ext.intrinsic ExtX86.sse1 "cvtsi642ss" + +cvtps2pi :: Ext.T (V4Float -> LLVM.CodeGenFunction r (MMX)) +cvtps2pi = Ext.intrinsic ExtX86.sse1 "cvtps2pi" + +cvttps2pi :: Ext.T (V4Float -> LLVM.CodeGenFunction r (MMX)) +cvttps2pi = Ext.intrinsic ExtX86.sse1 "cvttps2pi" + +cvtpi2ps :: Ext.T (V4Float -> MMX -> LLVM.CodeGenFunction r (V4Float)) +cvtpi2ps = Ext.intrinsic ExtX86.sse1 "cvtpi2ps" + +storeups :: Ext.T (LLVM.Value (Ptr ()) -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value ())) +storeups = Ext.intrinsic ExtX86.sse1 "storeu.ps" + +sfence :: Ext.T (LLVM.CodeGenFunction r (LLVM.Value ())) +sfence = Ext.intrinsic ExtX86.sse1 "sfence" + +movmskps :: Ext.T (V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +movmskps = Ext.intrinsic ExtX86.sse1 "movmsk.ps" + +addsd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +addsd = Ext.intrinsic ExtX86.sse2 "add.sd" + +subsd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +subsd = Ext.intrinsic ExtX86.sse2 "sub.sd" + +mulsd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +mulsd = Ext.intrinsic ExtX86.sse2 "mul.sd" + +divsd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +divsd = Ext.intrinsic ExtX86.sse2 "div.sd" + +sqrtsd :: Ext.T (V2Double -> LLVM.CodeGenFunction r (V2Double)) +sqrtsd = Ext.intrinsic ExtX86.sse2 "sqrt.sd" + +sqrtpd :: Ext.T (V2Double -> LLVM.CodeGenFunction r (V2Double)) +sqrtpd = Ext.intrinsic ExtX86.sse2 "sqrt.pd" + +minsd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +minsd = Ext.intrinsic ExtX86.sse2 "min.sd" + +minpd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +minpd = Ext.intrinsic ExtX86.sse2 "min.pd" + +maxsd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +maxsd = Ext.intrinsic ExtX86.sse2 "max.sd" + +maxpd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +maxpd = Ext.intrinsic ExtX86.sse2 "max.pd" + +cmpsd :: Ext.T (V2Double -> V2Double -> LLVM.Value W.Word8 -> LLVM.CodeGenFunction r (V2Double)) +cmpsd = Ext.intrinsic ExtX86.sse2 "cmp.sd" + +cmppd :: Ext.T (V2Double -> V2Double -> LLVM.Value W.Word8 -> LLVM.CodeGenFunction r (V2Double)) +cmppd = Ext.intrinsic ExtX86.sse2 "cmp.pd" + +comisdeq :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comisdeq = Ext.intrinsic ExtX86.sse2 "comieq.sd" + +comisdlt :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comisdlt = Ext.intrinsic ExtX86.sse2 "comilt.sd" + +comisdle :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comisdle = Ext.intrinsic ExtX86.sse2 "comile.sd" + +comisdgt :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comisdgt = Ext.intrinsic ExtX86.sse2 "comigt.sd" + +comisdge :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comisdge = Ext.intrinsic ExtX86.sse2 "comige.sd" + +comisdneq :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +comisdneq = Ext.intrinsic ExtX86.sse2 "comineq.sd" + +ucomisdeq :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomisdeq = Ext.intrinsic ExtX86.sse2 "ucomieq.sd" + +ucomisdlt :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomisdlt = Ext.intrinsic ExtX86.sse2 "ucomilt.sd" + +ucomisdle :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomisdle = Ext.intrinsic ExtX86.sse2 "ucomile.sd" + +ucomisdgt :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomisdgt = Ext.intrinsic ExtX86.sse2 "ucomigt.sd" + +ucomisdge :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomisdge = Ext.intrinsic ExtX86.sse2 "ucomige.sd" + +ucomisdneq :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ucomisdneq = Ext.intrinsic ExtX86.sse2 "ucomineq.sd" + +paddsb128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.CodeGenFunction r (V16Int8)) +paddsb128 = Ext.intrinsic ExtX86.sse2 "padds.b" + +paddsw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +paddsw128 = Ext.intrinsic ExtX86.sse2 "padds.w" + +paddusb128 :: Ext.T (V16Word8 -> V16Word8 -> LLVM.CodeGenFunction r (V16Word8)) +paddusb128 = Ext.intrinsic ExtX86.sse2 "paddus.b" + +paddusw128 :: Ext.T (V8Word16 -> V8Word16 -> LLVM.CodeGenFunction r (V8Word16)) +paddusw128 = Ext.intrinsic ExtX86.sse2 "paddus.w" + +psubsb128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.CodeGenFunction r (V16Int8)) +psubsb128 = Ext.intrinsic ExtX86.sse2 "psubs.b" + +psubsw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +psubsw128 = Ext.intrinsic ExtX86.sse2 "psubs.w" + +psubusb128 :: Ext.T (V16Word8 -> V16Word8 -> LLVM.CodeGenFunction r (V16Word8)) +psubusb128 = Ext.intrinsic ExtX86.sse2 "psubus.b" + +psubusw128 :: Ext.T (V8Word16 -> V8Word16 -> LLVM.CodeGenFunction r (V8Word16)) +psubusw128 = Ext.intrinsic ExtX86.sse2 "psubus.w" + +pmulhuw128 :: Ext.T (V8Word16 -> V8Word16 -> LLVM.CodeGenFunction r (V8Word16)) +pmulhuw128 = Ext.intrinsic ExtX86.sse2 "pmulhu.w" + +pmulhw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +pmulhw128 = Ext.intrinsic ExtX86.sse2 "pmulh.w" + +pmuludq128 :: Ext.T (V4Word32 -> V4Word32 -> LLVM.CodeGenFunction r (V2Word64)) +pmuludq128 = Ext.intrinsic ExtX86.sse2 "pmulu.dq" + +pmaddwd128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V4Int32)) +pmaddwd128 = Ext.intrinsic ExtX86.sse2 "pmadd.wd" + +pavgb128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.CodeGenFunction r (V16Int8)) +pavgb128 = Ext.intrinsic ExtX86.sse2 "pavg.b" + +pavgw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +pavgw128 = Ext.intrinsic ExtX86.sse2 "pavg.w" + +pmaxub128 :: Ext.T (V16Word8 -> V16Word8 -> LLVM.CodeGenFunction r (V16Word8)) +pmaxub128 = Ext.intrinsic ExtX86.sse2 "pmaxu.b" + +pmaxsw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +pmaxsw128 = Ext.intrinsic ExtX86.sse2 "pmaxs.w" + +pminub128 :: Ext.T (V16Word8 -> V16Word8 -> LLVM.CodeGenFunction r (V16Word8)) +pminub128 = Ext.intrinsic ExtX86.sse2 "pminu.b" + +pminsw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +pminsw128 = Ext.intrinsic ExtX86.sse2 "pmins.w" + +psadbw128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.CodeGenFunction r (V2Int64)) +psadbw128 = Ext.intrinsic ExtX86.sse2 "psad.bw" + +psllw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +psllw128 = Ext.intrinsic ExtX86.sse2 "psll.w" + +pslld128 :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +pslld128 = Ext.intrinsic ExtX86.sse2 "psll.d" + +psllq128 :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (V2Int64)) +psllq128 = Ext.intrinsic ExtX86.sse2 "psll.q" + +psrlw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +psrlw128 = Ext.intrinsic ExtX86.sse2 "psrl.w" + +psrld128 :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +psrld128 = Ext.intrinsic ExtX86.sse2 "psrl.d" + +psrlq128 :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (V2Int64)) +psrlq128 = Ext.intrinsic ExtX86.sse2 "psrl.q" + +psraw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +psraw128 = Ext.intrinsic ExtX86.sse2 "psra.w" + +psrad128 :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +psrad128 = Ext.intrinsic ExtX86.sse2 "psra.d" + +psllwi128 :: Ext.T (V8Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Int16)) +psllwi128 = Ext.intrinsic ExtX86.sse2 "pslli.w" + +pslldi128 :: Ext.T (V4Int32 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V4Int32)) +pslldi128 = Ext.intrinsic ExtX86.sse2 "pslli.d" + +psllqi128 :: Ext.T (V2Int64 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V2Int64)) +psllqi128 = Ext.intrinsic ExtX86.sse2 "pslli.q" + +psrlwi128 :: Ext.T (V8Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Int16)) +psrlwi128 = Ext.intrinsic ExtX86.sse2 "psrli.w" + +psrldi128 :: Ext.T (V4Int32 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V4Int32)) +psrldi128 = Ext.intrinsic ExtX86.sse2 "psrli.d" + +psrlqi128 :: Ext.T (V2Int64 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V2Int64)) +psrlqi128 = Ext.intrinsic ExtX86.sse2 "psrli.q" + +psrawi128 :: Ext.T (V8Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Int16)) +psrawi128 = Ext.intrinsic ExtX86.sse2 "psrai.w" + +psradi128 :: Ext.T (V4Int32 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V4Int32)) +psradi128 = Ext.intrinsic ExtX86.sse2 "psrai.d" + +cvtdq2pd :: Ext.T (V4Int32 -> LLVM.CodeGenFunction r (V2Double)) +cvtdq2pd = Ext.intrinsic ExtX86.sse2 "cvtdq2pd" + +cvtdq2ps :: Ext.T (V4Int32 -> LLVM.CodeGenFunction r (V4Float)) +cvtdq2ps = Ext.intrinsic ExtX86.sse2 "cvtdq2ps" + +cvtpd2dq :: Ext.T (V2Double -> LLVM.CodeGenFunction r (V4Int32)) +cvtpd2dq = Ext.intrinsic ExtX86.sse2 "cvtpd2dq" + +cvttpd2dq :: Ext.T (V2Double -> LLVM.CodeGenFunction r (V4Int32)) +cvttpd2dq = Ext.intrinsic ExtX86.sse2 "cvttpd2dq" + +cvtpd2ps :: Ext.T (V2Double -> LLVM.CodeGenFunction r (V4Float)) +cvtpd2ps = Ext.intrinsic ExtX86.sse2 "cvtpd2ps" + +cvtps2dq :: Ext.T (V4Float -> LLVM.CodeGenFunction r (V4Int32)) +cvtps2dq = Ext.intrinsic ExtX86.sse2 "cvtps2dq" + +cvttps2dq :: Ext.T (V4Float -> LLVM.CodeGenFunction r (V4Int32)) +cvttps2dq = Ext.intrinsic ExtX86.sse2 "cvttps2dq" + +cvtps2pd :: Ext.T (V4Float -> LLVM.CodeGenFunction r (V2Double)) +cvtps2pd = Ext.intrinsic ExtX86.sse2 "cvtps2pd" + +cvtsd2si :: Ext.T (V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +cvtsd2si = Ext.intrinsic ExtX86.sse2 "cvtsd2si" + +cvtsd2si64 :: Ext.T (V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int64)) +cvtsd2si64 = Ext.intrinsic ExtX86.sse2 "cvtsd2si64" + +cvttsd2si :: Ext.T (V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +cvttsd2si = Ext.intrinsic ExtX86.sse2 "cvttsd2si" + +cvttsd2si64 :: Ext.T (V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int64)) +cvttsd2si64 = Ext.intrinsic ExtX86.sse2 "cvttsd2si64" + +cvtsi2sd :: Ext.T (V2Double -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V2Double)) +cvtsi2sd = Ext.intrinsic ExtX86.sse2 "cvtsi2sd" + +cvtsi642sd :: Ext.T (V2Double -> LLVM.Value I.Int64 -> LLVM.CodeGenFunction r (V2Double)) +cvtsi642sd = Ext.intrinsic ExtX86.sse2 "cvtsi642sd" + +cvtsd2ss :: Ext.T (V4Float -> V2Double -> LLVM.CodeGenFunction r (V4Float)) +cvtsd2ss = Ext.intrinsic ExtX86.sse2 "cvtsd2ss" + +cvtss2sd :: Ext.T (V2Double -> V4Float -> LLVM.CodeGenFunction r (V2Double)) +cvtss2sd = Ext.intrinsic ExtX86.sse2 "cvtss2sd" + +cvtpd2pi :: Ext.T (V2Double -> LLVM.CodeGenFunction r (MMX)) +cvtpd2pi = Ext.intrinsic ExtX86.sse1 "cvtpd2pi" + +cvttpd2pi :: Ext.T (V2Double -> LLVM.CodeGenFunction r (MMX)) +cvttpd2pi = Ext.intrinsic ExtX86.sse1 "cvttpd2pi" + +cvtpi2pd :: Ext.T (MMX -> LLVM.CodeGenFunction r (V2Double)) +cvtpi2pd = Ext.intrinsic ExtX86.sse1 "cvtpi2pd" + +storeupd :: Ext.T (LLVM.Value (Ptr ()) -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value ())) +storeupd = Ext.intrinsic ExtX86.sse2 "storeu.pd" + +storedqu :: Ext.T (LLVM.Value (Ptr ()) -> V16Int8 -> LLVM.CodeGenFunction r (LLVM.Value ())) +storedqu = Ext.intrinsic ExtX86.sse2 "storeu.dq" + +storelv4si :: Ext.T (LLVM.Value (Ptr ()) -> V4Int32 -> LLVM.CodeGenFunction r (LLVM.Value ())) +storelv4si = Ext.intrinsic ExtX86.sse2 "storel.dq" + +packsswb128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V16Int8)) +packsswb128 = Ext.intrinsic ExtX86.sse2 "packsswb.128" + +packssdw128 :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V8Int16)) +packssdw128 = Ext.intrinsic ExtX86.sse2 "packssdw.128" + +packuswb128 :: Ext.T (V8Word16 -> V8Word16 -> LLVM.CodeGenFunction r (V16Word8)) +packuswb128 = Ext.intrinsic ExtX86.sse2 "packuswb.128" + +movmskpd :: Ext.T (V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +movmskpd = Ext.intrinsic ExtX86.sse2 "movmsk.pd" + +pmovmskb128 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pmovmskb128 = Ext.intrinsic ExtX86.sse2 "pmovmskb.128" + +maskmovdqu :: Ext.T (V16Int8 -> V16Int8 -> LLVM.Value (Ptr ()) -> LLVM.CodeGenFunction r (LLVM.Value ())) +maskmovdqu = Ext.intrinsic ExtX86.sse2 "maskmov.dqu" + +clflush :: Ext.T (LLVM.Value (Ptr ()) -> LLVM.CodeGenFunction r (LLVM.Value ())) +clflush = Ext.intrinsic ExtX86.sse2 "clflush" + +lfence :: Ext.T (LLVM.CodeGenFunction r (LLVM.Value ())) +lfence = Ext.intrinsic ExtX86.sse2 "lfence" + +mfence :: Ext.T (LLVM.CodeGenFunction r (LLVM.Value ())) +mfence = Ext.intrinsic ExtX86.sse2 "mfence" + +pause :: Ext.T (LLVM.CodeGenFunction r (LLVM.Value ())) +pause = Ext.intrinsic ExtX86.sse2 "pause" + +addsubps :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +addsubps = Ext.intrinsic ExtX86.sse3 "addsub.ps" + +addsubpd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +addsubpd = Ext.intrinsic ExtX86.sse3 "addsub.pd" + +haddps :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +haddps = Ext.intrinsic ExtX86.sse3 "hadd.ps" + +haddpd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +haddpd = Ext.intrinsic ExtX86.sse3 "hadd.pd" + +hsubps :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +hsubps = Ext.intrinsic ExtX86.sse3 "hsub.ps" + +hsubpd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +hsubpd = Ext.intrinsic ExtX86.sse3 "hsub.pd" + +lddqu :: Ext.T (LLVM.Value (Ptr ()) -> LLVM.CodeGenFunction r (V16Int8)) +lddqu = Ext.intrinsic ExtX86.sse3 "ldu.dq" + +monitor :: Ext.T (LLVM.Value (Ptr ()) -> LLVM.Value I.Int32 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (LLVM.Value ())) +monitor = Ext.intrinsic ExtX86.sse3 "monitor" + +mwait :: Ext.T (LLVM.Value I.Int32 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (LLVM.Value ())) +mwait = Ext.intrinsic ExtX86.sse3 "mwait" + +phaddw :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +phaddw = Ext.intrinsic ExtX86.ssse3 "phadd.w" + +phaddw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +phaddw128 = Ext.intrinsic ExtX86.ssse3 "phadd.w.128" + +phaddd :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +phaddd = Ext.intrinsic ExtX86.ssse3 "phadd.d" + +phaddd128 :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +phaddd128 = Ext.intrinsic ExtX86.ssse3 "phadd.d.128" + +phaddsw :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +phaddsw = Ext.intrinsic ExtX86.ssse3 "phadd.sw" + +phaddsw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +phaddsw128 = Ext.intrinsic ExtX86.ssse3 "phadd.sw.128" + +phsubw :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +phsubw = Ext.intrinsic ExtX86.ssse3 "phsub.w" + +phsubw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +phsubw128 = Ext.intrinsic ExtX86.ssse3 "phsub.w.128" + +phsubd :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +phsubd = Ext.intrinsic ExtX86.ssse3 "phsub.d" + +phsubd128 :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +phsubd128 = Ext.intrinsic ExtX86.ssse3 "phsub.d.128" + +phsubsw :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +phsubsw = Ext.intrinsic ExtX86.ssse3 "phsub.sw" + +phsubsw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +phsubsw128 = Ext.intrinsic ExtX86.ssse3 "phsub.sw.128" + +pmaddubsw :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pmaddubsw = Ext.intrinsic ExtX86.ssse3 "pmadd.ub.sw" + +pmaddubsw128 :: Ext.T (V16Word8 -> V16Word8 -> LLVM.CodeGenFunction r (V8Word16)) +pmaddubsw128 = Ext.intrinsic ExtX86.ssse3 "pmadd.ub.sw.128" + +pmulhrsw :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pmulhrsw = Ext.intrinsic ExtX86.ssse3 "pmul.hr.sw" + +pmulhrsw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +pmulhrsw128 = Ext.intrinsic ExtX86.ssse3 "pmul.hr.sw.128" + +pshufb :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +pshufb = Ext.intrinsic ExtX86.ssse3 "pshuf.b" + +pshufb128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.CodeGenFunction r (V16Int8)) +pshufb128 = Ext.intrinsic ExtX86.ssse3 "pshuf.b.128" + +pshufd :: Ext.T (V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +pshufd = Ext.intrinsic ExtX86.sse2 "pshuf.d" + +pshuflw :: Ext.T (V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pshuflw = Ext.intrinsic ExtX86.sse2 "pshufl.w" + +pshufhw :: Ext.T (V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pshufhw = Ext.intrinsic ExtX86.sse2 "pshufh.w" + +pshufw :: Ext.T (MMX -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (MMX)) +pshufw = Ext.intrinsic ExtX86.sse1 "pshuf.w" + +psignb :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +psignb = Ext.intrinsic ExtX86.ssse3 "psign.b" + +psignb128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.CodeGenFunction r (V16Int8)) +psignb128 = Ext.intrinsic ExtX86.ssse3 "psign.b.128" + +psignw :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +psignw = Ext.intrinsic ExtX86.ssse3 "psign.w" + +psignw128 :: Ext.T (V8Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +psignw128 = Ext.intrinsic ExtX86.ssse3 "psign.w.128" + +psignd :: Ext.T (MMX -> MMX -> LLVM.CodeGenFunction r (MMX)) +psignd = Ext.intrinsic ExtX86.ssse3 "psign.d" + +psignd128 :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +psignd128 = Ext.intrinsic ExtX86.ssse3 "psign.d.128" + +pabsb :: Ext.T (MMX -> LLVM.CodeGenFunction r (MMX)) +pabsb = Ext.intrinsic ExtX86.ssse3 "pabs.b" + +pabsb128 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V16Int8)) +pabsb128 = Ext.intrinsic ExtX86.ssse3 "pabs.b.128" + +pabsw :: Ext.T (MMX -> LLVM.CodeGenFunction r (MMX)) +pabsw = Ext.intrinsic ExtX86.ssse3 "pabs.w" + +pabsw128 :: Ext.T (V8Int16 -> LLVM.CodeGenFunction r (V8Int16)) +pabsw128 = Ext.intrinsic ExtX86.ssse3 "pabs.w.128" + +pabsd :: Ext.T (MMX -> LLVM.CodeGenFunction r (MMX)) +pabsd = Ext.intrinsic ExtX86.ssse3 "pabs.d" + +pabsd128 :: Ext.T (V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +pabsd128 = Ext.intrinsic ExtX86.ssse3 "pabs.d.128" + +roundss :: Ext.T (V4Float -> V4Float -> LLVM.Value W.Word32 -> LLVM.CodeGenFunction r (V4Float)) +roundss = Ext.intrinsic ExtX86.sse41 "round.ss" + +roundps :: Ext.T (V4Float -> LLVM.Value W.Word32 -> LLVM.CodeGenFunction r (V4Float)) +roundps = Ext.intrinsic ExtX86.sse41 "round.ps" + +roundsd :: Ext.T (V2Double -> V2Double -> LLVM.Value W.Word32 -> LLVM.CodeGenFunction r (V2Double)) +roundsd = Ext.intrinsic ExtX86.sse41 "round.sd" + +roundpd :: Ext.T (V2Double -> LLVM.Value W.Word32 -> LLVM.CodeGenFunction r (V2Double)) +roundpd = Ext.intrinsic ExtX86.sse41 "round.pd" + +pmovsxbd128 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V4Int32)) +pmovsxbd128 = Ext.intrinsic ExtX86.sse41 "pmovsxbd" + +pmovsxbq128 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V2Int64)) +pmovsxbq128 = Ext.intrinsic ExtX86.sse41 "pmovsxbq" + +pmovsxbw128 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pmovsxbw128 = Ext.intrinsic ExtX86.sse41 "pmovsxbw" + +pmovsxdq128 :: Ext.T (V4Int32 -> LLVM.CodeGenFunction r (V2Int64)) +pmovsxdq128 = Ext.intrinsic ExtX86.sse41 "pmovsxdq" + +pmovsxwd128 :: Ext.T (V8Int16 -> LLVM.CodeGenFunction r (V4Int32)) +pmovsxwd128 = Ext.intrinsic ExtX86.sse41 "pmovsxwd" + +pmovsxwq128 :: Ext.T (V8Int16 -> LLVM.CodeGenFunction r (V2Int64)) +pmovsxwq128 = Ext.intrinsic ExtX86.sse41 "pmovsxwq" + +pmovzxbd128 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V4Int32)) +pmovzxbd128 = Ext.intrinsic ExtX86.sse41 "pmovzxbd" + +pmovzxbq128 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V2Int64)) +pmovzxbq128 = Ext.intrinsic ExtX86.sse41 "pmovzxbq" + +pmovzxbw128 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pmovzxbw128 = Ext.intrinsic ExtX86.sse41 "pmovzxbw" + +pmovzxdq128 :: Ext.T (V4Int32 -> LLVM.CodeGenFunction r (V2Int64)) +pmovzxdq128 = Ext.intrinsic ExtX86.sse41 "pmovzxdq" + +pmovzxwd128 :: Ext.T (V8Int16 -> LLVM.CodeGenFunction r (V4Int32)) +pmovzxwd128 = Ext.intrinsic ExtX86.sse41 "pmovzxwd" + +pmovzxwq128 :: Ext.T (V8Int16 -> LLVM.CodeGenFunction r (V2Int64)) +pmovzxwq128 = Ext.intrinsic ExtX86.sse41 "pmovzxwq" + +phminposuw128 :: Ext.T (V8Word16 -> LLVM.CodeGenFunction r (V8Word16)) +phminposuw128 = Ext.intrinsic ExtX86.sse41 "phminposuw" + +pmaxsb128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.CodeGenFunction r (V16Int8)) +pmaxsb128 = Ext.intrinsic ExtX86.sse41 "pmaxsb" + +pmaxsd128 :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +pmaxsd128 = Ext.intrinsic ExtX86.sse41 "pmaxsd" + +pmaxud128 :: Ext.T (V4Word32 -> V4Word32 -> LLVM.CodeGenFunction r (V4Word32)) +pmaxud128 = Ext.intrinsic ExtX86.sse41 "pmaxud" + +pmaxuw128 :: Ext.T (V8Word16 -> V8Word16 -> LLVM.CodeGenFunction r (V8Word16)) +pmaxuw128 = Ext.intrinsic ExtX86.sse41 "pmaxuw" + +pminsb128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.CodeGenFunction r (V16Int8)) +pminsb128 = Ext.intrinsic ExtX86.sse41 "pminsb" + +pminsd128 :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +pminsd128 = Ext.intrinsic ExtX86.sse41 "pminsd" + +pminud128 :: Ext.T (V4Word32 -> V4Word32 -> LLVM.CodeGenFunction r (V4Word32)) +pminud128 = Ext.intrinsic ExtX86.sse41 "pminud" + +pminuw128 :: Ext.T (V8Word16 -> V8Word16 -> LLVM.CodeGenFunction r (V8Word16)) +pminuw128 = Ext.intrinsic ExtX86.sse41 "pminuw" + +aesimc128 :: Ext.T (V2Int64 -> LLVM.CodeGenFunction r (V2Int64)) +aesimc128 = Ext.intrinsic ExtX86.aes "aesimc" + +aesenc128 :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (V2Int64)) +aesenc128 = Ext.intrinsic ExtX86.aes "aesenc" + +aesenclast128 :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (V2Int64)) +aesenclast128 = Ext.intrinsic ExtX86.aes "aesenclast" + +aesdec128 :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (V2Int64)) +aesdec128 = Ext.intrinsic ExtX86.aes "aesdec" + +aesdeclast128 :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (V2Int64)) +aesdeclast128 = Ext.intrinsic ExtX86.aes "aesdeclast" + +aeskeygenassist128 :: Ext.T (V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +aeskeygenassist128 = Ext.intrinsic ExtX86.aes "aeskeygenassist" + +{- +pclmulqdq128 :: Ext.T (V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +pclmulqdq128 = Ext.intrinsic ExtX86. "int.x86.pclmulqdq" +-} + +packusdw128 :: Ext.T (V4Word32 -> V4Word32 -> LLVM.CodeGenFunction r (V8Word16)) +packusdw128 = Ext.intrinsic ExtX86.sse41 "packusdw" + +pmuldq128 :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V2Int64)) +pmuldq128 = Ext.intrinsic ExtX86.sse41 "pmuldq" + +extractps128 :: Ext.T (V4Float -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +extractps128 = Ext.intrinsic ExtX86.sse41 "extractps" + +insertps128 :: Ext.T (V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +insertps128 = Ext.intrinsic ExtX86.sse41 "insertps" + +pblendvb128 :: Ext.T (V16Int8 -> V16Int8 -> V16Int8 -> LLVM.CodeGenFunction r (V16Int8)) +pblendvb128 = Ext.intrinsic ExtX86.sse41 "pblendvb" + +blendvpd :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +blendvpd = Ext.intrinsic ExtX86.sse41 "blendvpd" + +blendvps :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +blendvps = Ext.intrinsic ExtX86.sse41 "blendvps" + +dppd :: Ext.T (V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +dppd = Ext.intrinsic ExtX86.sse41 "dppd" + +dpps :: Ext.T (V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +dpps = Ext.intrinsic ExtX86.sse41 "dpps" + +mpsadbw128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +mpsadbw128 = Ext.intrinsic ExtX86.sse41 "mpsadbw" + +movntdqa :: Ext.T (LLVM.Value (Ptr ()) -> LLVM.CodeGenFunction r (V2Int64)) +movntdqa = Ext.intrinsic ExtX86.sse41 "movntdqa" + +ptestz128 :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ptestz128 = Ext.intrinsic ExtX86.sse41 "ptestz" + +ptestc128 :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ptestc128 = Ext.intrinsic ExtX86.sse41 "ptestc" + +ptestnzc128 :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ptestnzc128 = Ext.intrinsic ExtX86.sse41 "ptestnzc" + +crc32qi :: Ext.T (LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +crc32qi = Ext.intrinsic ExtX86.sse42 "crc32.32.8" + +crc32hi :: Ext.T (LLVM.Value I.Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +crc32hi = Ext.intrinsic ExtX86.sse42 "crc32.32.16" + +crc32si :: Ext.T (LLVM.Value I.Int32 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +crc32si = Ext.intrinsic ExtX86.sse42 "crc32.32.32" + +crc32di :: Ext.T (LLVM.Value I.Int64 -> LLVM.Value I.Int64 -> LLVM.CodeGenFunction r (LLVM.Value I.Int64)) +crc32di = Ext.intrinsic ExtX86.sse42 "crc32.64.64" + +pcmpistrm128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V16Int8)) +pcmpistrm128 = Ext.intrinsic ExtX86.sse42 "pcmpistrm128" + +pcmpistri128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpistri128 = Ext.intrinsic ExtX86.sse42 "pcmpistri128" + +pcmpistria128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpistria128 = Ext.intrinsic ExtX86.sse42 "pcmpistria128" + +pcmpistric128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpistric128 = Ext.intrinsic ExtX86.sse42 "pcmpistric128" + +pcmpistrio128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpistrio128 = Ext.intrinsic ExtX86.sse42 "pcmpistrio128" + +pcmpistris128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpistris128 = Ext.intrinsic ExtX86.sse42 "pcmpistris128" + +pcmpistriz128 :: Ext.T (V16Int8 -> V16Int8 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpistriz128 = Ext.intrinsic ExtX86.sse42 "pcmpistriz128" + +pcmpestrm128 :: Ext.T (V16Int8 -> LLVM.Value I.Int32 -> V16Int8 -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V16Int8)) +pcmpestrm128 = Ext.intrinsic ExtX86.sse42 "pcmpestrm128" + +pcmpestri128 :: Ext.T (V16Int8 -> LLVM.Value I.Int32 -> V16Int8 -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpestri128 = Ext.intrinsic ExtX86.sse42 "pcmpestri128" + +pcmpestria128 :: Ext.T (V16Int8 -> LLVM.Value I.Int32 -> V16Int8 -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpestria128 = Ext.intrinsic ExtX86.sse42 "pcmpestria128" + +pcmpestric128 :: Ext.T (V16Int8 -> LLVM.Value I.Int32 -> V16Int8 -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpestric128 = Ext.intrinsic ExtX86.sse42 "pcmpestric128" + +pcmpestrio128 :: Ext.T (V16Int8 -> LLVM.Value I.Int32 -> V16Int8 -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpestrio128 = Ext.intrinsic ExtX86.sse42 "pcmpestrio128" + +pcmpestris128 :: Ext.T (V16Int8 -> LLVM.Value I.Int32 -> V16Int8 -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpestris128 = Ext.intrinsic ExtX86.sse42 "pcmpestris128" + +pcmpestriz128 :: Ext.T (V16Int8 -> LLVM.Value I.Int32 -> V16Int8 -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pcmpestriz128 = Ext.intrinsic ExtX86.sse42 "pcmpestriz128" + +extrqi :: Ext.T (V2Int64 -> LLVM.Value I.Int8 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +extrqi = Ext.intrinsic ExtX86.sse4a "extrqi" + +extrq :: Ext.T (V2Int64 -> V16Int8 -> LLVM.CodeGenFunction r (V2Int64)) +extrq = Ext.intrinsic ExtX86.sse4a "extrq" + +insertqi :: Ext.T (V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +insertqi = Ext.intrinsic ExtX86.sse4a "insertqi" + +insertq :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (V2Int64)) +insertq = Ext.intrinsic ExtX86.sse4a "insertq" + +movntss :: Ext.T (LLVM.Value (Ptr ()) -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value ())) +movntss = Ext.intrinsic ExtX86.sse4a "movnt.ss" + +movntsd :: Ext.T (LLVM.Value (Ptr ()) -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value ())) +movntsd = Ext.intrinsic ExtX86.sse4a "movnt.sd" + +addsubpd256 :: Ext.T (V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +addsubpd256 = Ext.intrinsic ExtX86.avx "addsub.pd.256" + +addsubps256 :: Ext.T (V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +addsubps256 = Ext.intrinsic ExtX86.avx "addsub.ps.256" + +maxpd256 :: Ext.T (V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +maxpd256 = Ext.intrinsic ExtX86.avx "max.pd.256" + +maxps256 :: Ext.T (V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +maxps256 = Ext.intrinsic ExtX86.avx "max.ps.256" + +minpd256 :: Ext.T (V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +minpd256 = Ext.intrinsic ExtX86.avx "min.pd.256" + +minps256 :: Ext.T (V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +minps256 = Ext.intrinsic ExtX86.avx "min.ps.256" + +sqrtpd256 :: Ext.T (V4Double -> LLVM.CodeGenFunction r (V4Double)) +sqrtpd256 = Ext.intrinsic ExtX86.avx "sqrt.pd.256" + +sqrtps256 :: Ext.T (V8Float -> LLVM.CodeGenFunction r (V8Float)) +sqrtps256 = Ext.intrinsic ExtX86.avx "sqrt.ps.256" + +rsqrtps256 :: Ext.T (V8Float -> LLVM.CodeGenFunction r (V8Float)) +rsqrtps256 = Ext.intrinsic ExtX86.avx "rsqrt.ps.256" + +rcpps256 :: Ext.T (V8Float -> LLVM.CodeGenFunction r (V8Float)) +rcpps256 = Ext.intrinsic ExtX86.avx "rcp.ps.256" + +roundpd256 :: Ext.T (V4Double -> LLVM.Value W.Word32 -> LLVM.CodeGenFunction r (V4Double)) +roundpd256 = Ext.intrinsic ExtX86.avx "round.pd.256" + +roundps256 :: Ext.T (V8Float -> LLVM.Value W.Word32 -> LLVM.CodeGenFunction r (V8Float)) +roundps256 = Ext.intrinsic ExtX86.avx "round.ps.256" + +haddpd256 :: Ext.T (V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +haddpd256 = Ext.intrinsic ExtX86.avx "hadd.pd.256" + +hsubps256 :: Ext.T (V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +hsubps256 = Ext.intrinsic ExtX86.avx "hsub.ps.256" + +hsubpd256 :: Ext.T (V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +hsubpd256 = Ext.intrinsic ExtX86.avx "hsub.pd.256" + +haddps256 :: Ext.T (V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +haddps256 = Ext.intrinsic ExtX86.avx "hadd.ps.256" + +vpermilvarpd :: Ext.T (V2Double -> V2Int64 -> LLVM.CodeGenFunction r (V2Double)) +vpermilvarpd = Ext.intrinsic ExtX86.avx "vpermilvar.pd" + +vpermilvarps :: Ext.T (V4Float -> V4Int32 -> LLVM.CodeGenFunction r (V4Float)) +vpermilvarps = Ext.intrinsic ExtX86.avx "vpermilvar.ps" + +vpermilvarpd256 :: Ext.T (V4Double -> V4Int64 -> LLVM.CodeGenFunction r (V4Double)) +vpermilvarpd256 = Ext.intrinsic ExtX86.avx "vpermilvar.pd.256" + +vpermilvarps256 :: Ext.T (V8Float -> V8Int32 -> LLVM.CodeGenFunction r (V8Float)) +vpermilvarps256 = Ext.intrinsic ExtX86.avx "vpermilvar.ps.256" + +vperm2f128_pd256 :: Ext.T (V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vperm2f128_pd256 = Ext.intrinsic ExtX86.avx "vperm2f128.pd.256" + +vperm2f128_ps256 :: Ext.T (V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vperm2f128_ps256 = Ext.intrinsic ExtX86.avx "vperm2f128.ps.256" + +vperm2f128_si256 :: Ext.T (V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +vperm2f128_si256 = Ext.intrinsic ExtX86.avx "vperm2f128.si.256" + +vpermi2vard128_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +vpermi2vard128_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.d.128" + +vpermi2vard256_mask :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +vpermi2vard256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.d.256" + +vpermi2vard512_mask :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +vpermi2vard512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.d.512" + +vpermi2varhi128_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +vpermi2varhi128_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.hi.128" + +vpermi2varhi256_mask :: Ext.T (V16Int16 -> V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +vpermi2varhi256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.hi.256" + +vpermi2varhi512_mask :: Ext.T (V32Int16 -> V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +vpermi2varhi512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.hi.512" + +vpermi2varpd128_mask :: Ext.T (V2Double -> V2Int64 -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vpermi2varpd128_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.pd.128" + +vpermi2varpd256_mask :: Ext.T (V4Double -> V4Int64 -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vpermi2varpd256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.pd.256" + +vpermi2varpd512_mask :: Ext.T (V8Double -> V8Int64 -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +vpermi2varpd512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.pd.512" + +vpermi2varps128_mask :: Ext.T (V4Float -> V4Int32 -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vpermi2varps128_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.ps.128" + +vpermi2varps256_mask :: Ext.T (V8Float -> V8Int32 -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vpermi2varps256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.ps.256" + +vpermi2varps512_mask :: Ext.T (V16Float -> V16Int32 -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +vpermi2varps512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.ps.512" + +vpermi2varq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +vpermi2varq128_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.q.128" + +vpermi2varq256_mask :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +vpermi2varq256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.q.256" + +vpermi2varq512_mask :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +vpermi2varq512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermi2var.q.512" + +vpermt2vard512_mask :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +vpermt2vard512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.d.512" + +vpermt2varq512_mask :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +vpermt2varq512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.q.512" + +vpermt2varps512_mask :: Ext.T (V16Int32 -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +vpermt2varps512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.ps.512" + +vpermt2varpd512_mask :: Ext.T (V8Int64 -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +vpermt2varpd512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.pd.512" + +vpermt2vard128_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +vpermt2vard128_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.d.128" + +vpermt2vard128_maskz :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +vpermt2vard128_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.d.128" + +vpermt2vard256_mask :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +vpermt2vard256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.d.256" + +vpermt2vard256_maskz :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +vpermt2vard256_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.d.256" + +vpermt2vard512_maskz :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +vpermt2vard512_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.d.512" + +vpermt2varhi128_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +vpermt2varhi128_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.hi.128" + +vpermt2varhi128_maskz :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +vpermt2varhi128_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.hi.128" + +vpermt2varhi256_mask :: Ext.T (V16Int16 -> V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +vpermt2varhi256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.hi.256" + +vpermt2varhi256_maskz :: Ext.T (V16Int16 -> V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +vpermt2varhi256_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.hi.256" + +vpermt2varhi512_mask :: Ext.T (V32Int16 -> V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +vpermt2varhi512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.hi.512" + +vpermt2varhi512_maskz :: Ext.T (V32Int16 -> V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +vpermt2varhi512_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.hi.512" + +vpermt2varpd128_mask :: Ext.T (V2Int64 -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vpermt2varpd128_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.pd.128" + +vpermt2varpd128_maskz :: Ext.T (V2Int64 -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vpermt2varpd128_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.pd.128" + +vpermt2varpd256_mask :: Ext.T (V4Int64 -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vpermt2varpd256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.pd.256" + +vpermt2varpd256_maskz :: Ext.T (V4Int64 -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vpermt2varpd256_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.pd.256" + +vpermt2varpd512_maskz :: Ext.T (V8Int64 -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +vpermt2varpd512_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.pd.512" + +vpermt2varps128_mask :: Ext.T (V4Int32 -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vpermt2varps128_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.ps.128" + +vpermt2varps128_maskz :: Ext.T (V4Int32 -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vpermt2varps128_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.ps.128" + +vpermt2varps256_mask :: Ext.T (V8Int32 -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vpermt2varps256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.ps.256" + +vpermt2varps256_maskz :: Ext.T (V8Int32 -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vpermt2varps256_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.ps.256" + +vpermt2varps512_maskz :: Ext.T (V16Int32 -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +vpermt2varps512_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.ps.512" + +vpermt2varq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +vpermt2varq128_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.q.128" + +vpermt2varq128_maskz :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +vpermt2varq128_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.q.128" + +vpermt2varq256_mask :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +vpermt2varq256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermt2var.q.256" + +vpermt2varq256_maskz :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +vpermt2varq256_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.q.256" + +vpermt2varq512_maskz :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +vpermt2varq512_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vpermt2var.q.512" + +vpermilpd_mask :: Ext.T (V2Double -> LLVM.Value I.Int32 -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vpermilpd_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermil.pd.128" + +vpermilpd256_mask :: Ext.T (V4Double -> LLVM.Value I.Int32 -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vpermilpd256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermil.pd.256" + +vpermilpd512_mask :: Ext.T (V8Double -> LLVM.Value I.Int32 -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +vpermilpd512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermil.pd.512" + +vpermilps_mask :: Ext.T (V4Float -> LLVM.Value I.Int32 -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vpermilps_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermil.ps.128" + +vpermilps256_mask :: Ext.T (V8Float -> LLVM.Value I.Int32 -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vpermilps256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermil.ps.256" + +vpermilps512_mask :: Ext.T (V16Float -> LLVM.Value I.Int32 -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +vpermilps512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermil.ps.512" + +vpermilvarpd256_mask :: Ext.T (V4Double -> V4Int64 -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vpermilvarpd256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermilvar.pd.256" + +vpermilvarpd512_mask :: Ext.T (V8Double -> V8Int64 -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +vpermilvarpd512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermilvar.pd.512" + +vpermilvarpd_mask :: Ext.T (V2Double -> V2Int64 -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vpermilvarpd_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermilvar.pd.128" + +vpermilvarps256_mask :: Ext.T (V8Float -> V8Int32 -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vpermilvarps256_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermilvar.ps.256" + +vpermilvarps512_mask :: Ext.T (V16Float -> V16Int32 -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +vpermilvarps512_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermilvar.ps.512" + +vpermilvarps_mask :: Ext.T (V4Float -> V4Int32 -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vpermilvarps_mask = Ext.intrinsic ExtX86.avx512 "mask.vpermilvar.ps.128" + +pshufb128_mask :: Ext.T (V16Int8 -> V16Int8 -> V16Int8 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int8)) +pshufb128_mask = Ext.intrinsic ExtX86.avx512 "mask.pshuf.b.128" + +pshufb256_mask :: Ext.T (V32Int8 -> V32Int8 -> V32Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int8)) +pshufb256_mask = Ext.intrinsic ExtX86.avx512 "mask.pshuf.b.256" + +pshufb512_mask :: Ext.T (V64Int8 -> V64Int8 -> V64Int8 -> LLVM.Value I.Int64 -> LLVM.CodeGenFunction r (V64Int8)) +pshufb512_mask = Ext.intrinsic ExtX86.avx512 "mask.pshuf.b.512" + +pshufd128_mask :: Ext.T (V4Int32 -> LLVM.Value I.Int16 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +pshufd128_mask = Ext.intrinsic ExtX86.avx512 "mask.pshuf.d.128" + +pshufd256_mask :: Ext.T (V8Int32 -> LLVM.Value I.Int16 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +pshufd256_mask = Ext.intrinsic ExtX86.avx512 "mask.pshuf.d.256" + +pshufd512_mask :: Ext.T (V16Int32 -> LLVM.Value I.Int16 -> V16Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V16Int32)) +pshufd512_mask = Ext.intrinsic ExtX86.avx512 "mask.pshuf.d.512" + +pshufhw128_mask :: Ext.T (V8Int16 -> LLVM.Value I.Int8 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pshufhw128_mask = Ext.intrinsic ExtX86.avx512 "mask.pshufh.w.128" + +pshufhw256_mask :: Ext.T (V16Int16 -> LLVM.Value I.Int8 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pshufhw256_mask = Ext.intrinsic ExtX86.avx512 "mask.pshufh.w.256" + +pshufhw512_mask :: Ext.T (V32Int16 -> LLVM.Value I.Int8 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +pshufhw512_mask = Ext.intrinsic ExtX86.avx512 "mask.pshufh.w.512" + +pshuflw128_mask :: Ext.T (V8Int16 -> LLVM.Value I.Int8 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pshuflw128_mask = Ext.intrinsic ExtX86.avx512 "mask.pshufl.w.128" + +pshuflw256_mask :: Ext.T (V16Int16 -> LLVM.Value I.Int8 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pshuflw256_mask = Ext.intrinsic ExtX86.avx512 "mask.pshufl.w.256" + +pshuflw512_mask :: Ext.T (V32Int16 -> LLVM.Value I.Int8 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +pshuflw512_mask = Ext.intrinsic ExtX86.avx512 "mask.pshufl.w.512" + +shuf_f32x4_256_mask :: Ext.T (V8Float -> V8Float -> LLVM.Value I.Int32 -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +shuf_f32x4_256_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.f32x4.256" + +shuf_f32x4_mask :: Ext.T (V16Float -> V16Float -> LLVM.Value I.Int32 -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +shuf_f32x4_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.f32x4" + +shuf_f64x2_256_mask :: Ext.T (V4Double -> V4Double -> LLVM.Value I.Int32 -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +shuf_f64x2_256_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.f64x2.256" + +shuf_f64x2_mask :: Ext.T (V8Double -> V8Double -> LLVM.Value I.Int32 -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +shuf_f64x2_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.f64x2" + +shuf_i32x4_256_mask :: Ext.T (V8Int32 -> V8Int32 -> LLVM.Value I.Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +shuf_i32x4_256_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.i32x4.256" + +shuf_i32x4_mask :: Ext.T (V16Int32 -> V16Int32 -> LLVM.Value I.Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +shuf_i32x4_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.i32x4" + +shuf_i64x2_256_mask :: Ext.T (V4Int64 -> V4Int64 -> LLVM.Value I.Int32 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +shuf_i64x2_256_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.i64x2.256" + +shuf_i64x2_mask :: Ext.T (V8Int64 -> V8Int64 -> LLVM.Value I.Int32 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +shuf_i64x2_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.i64x2" + +shufpd128_mask :: Ext.T (V2Double -> V2Double -> LLVM.Value I.Int32 -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +shufpd128_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.pd.128" + +shufpd256_mask :: Ext.T (V4Double -> V4Double -> LLVM.Value I.Int32 -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +shufpd256_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.pd.256" + +shufpd512_mask :: Ext.T (V8Double -> V8Double -> LLVM.Value I.Int32 -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +shufpd512_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.pd.512" + +shufps128_mask :: Ext.T (V4Float -> V4Float -> LLVM.Value I.Int32 -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +shufps128_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.ps.128" + +shufps256_mask :: Ext.T (V8Float -> V8Float -> LLVM.Value I.Int32 -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +shufps256_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.ps.256" + +shufps512_mask :: Ext.T (V16Float -> V16Float -> LLVM.Value I.Int32 -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +shufps512_mask = Ext.intrinsic ExtX86.avx512 "mask.shuf.ps.512" + +movshdup128_mask :: Ext.T (V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +movshdup128_mask = Ext.intrinsic ExtX86.avx512 "mask.movshdup.128" + +movshdup256_mask :: Ext.T (V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +movshdup256_mask = Ext.intrinsic ExtX86.avx512 "mask.movshdup.256" + +movshdup512_mask :: Ext.T (V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +movshdup512_mask = Ext.intrinsic ExtX86.avx512 "mask.movshdup.512" + +movsldup128_mask :: Ext.T (V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +movsldup128_mask = Ext.intrinsic ExtX86.avx512 "mask.movsldup.128" + +movsldup256_mask :: Ext.T (V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +movsldup256_mask = Ext.intrinsic ExtX86.avx512 "mask.movsldup.256" + +movsldup512_mask :: Ext.T (V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +movsldup512_mask = Ext.intrinsic ExtX86.avx512 "mask.movsldup.512" + +movddup128_mask :: Ext.T (V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +movddup128_mask = Ext.intrinsic ExtX86.avx512 "mask.movddup.128" + +movddup256_mask :: Ext.T (V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +movddup256_mask = Ext.intrinsic ExtX86.avx512 "mask.movddup.256" + +movddup512_mask :: Ext.T (V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +movddup512_mask = Ext.intrinsic ExtX86.avx512 "mask.movddup.512" + +blendvpd256 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +blendvpd256 = Ext.intrinsic ExtX86.avx "blendv.pd.256" + +blendvps256 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +blendvps256 = Ext.intrinsic ExtX86.avx "blendv.ps.256" + +dpps256 :: Ext.T (V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +dpps256 = Ext.intrinsic ExtX86.avx "dp.ps.256" + +cmppd256 :: Ext.T (V4Double -> V4Double -> LLVM.Value W.Word8 -> LLVM.CodeGenFunction r (V4Double)) +cmppd256 = Ext.intrinsic ExtX86.avx "cmp.pd.256" + +cmpps256 :: Ext.T (V8Float -> V8Float -> LLVM.Value W.Word8 -> LLVM.CodeGenFunction r (V8Float)) +cmpps256 = Ext.intrinsic ExtX86.avx "cmp.ps.256" + +cvtdq2pd256 :: Ext.T (V4Int32 -> LLVM.CodeGenFunction r (V4Double)) +cvtdq2pd256 = Ext.intrinsic ExtX86.avx "cvtdq2.pd.256" + +cvtdq2ps256 :: Ext.T (V8Int32 -> LLVM.CodeGenFunction r (V8Float)) +cvtdq2ps256 = Ext.intrinsic ExtX86.avx "cvtdq2.ps.256" + +cvtpd2ps256 :: Ext.T (V4Double -> LLVM.CodeGenFunction r (V4Float)) +cvtpd2ps256 = Ext.intrinsic ExtX86.avx "cvt.pd2.ps.256" + +cvtps2dq256 :: Ext.T (V8Float -> LLVM.CodeGenFunction r (V8Int32)) +cvtps2dq256 = Ext.intrinsic ExtX86.avx "cvt.ps2dq.256" + +cvtps2pd256 :: Ext.T (V4Float -> LLVM.CodeGenFunction r (V4Double)) +cvtps2pd256 = Ext.intrinsic ExtX86.avx "cvt.ps2.pd.256" + +cvttpd2dq256 :: Ext.T (V4Double -> LLVM.CodeGenFunction r (V4Int32)) +cvttpd2dq256 = Ext.intrinsic ExtX86.avx "cvtt.pd2dq.256" + +cvtpd2dq256 :: Ext.T (V4Double -> LLVM.CodeGenFunction r (V4Int32)) +cvtpd2dq256 = Ext.intrinsic ExtX86.avx "cvt.pd2dq.256" + +cvttps2dq256 :: Ext.T (V8Float -> LLVM.CodeGenFunction r (V8Int32)) +cvttps2dq256 = Ext.intrinsic ExtX86.avx "cvtt.ps2dq.256" + +vtestzpd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestzpd = Ext.intrinsic ExtX86.avx "vtestz.pd" + +vtestcpd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestcpd = Ext.intrinsic ExtX86.avx "vtestc.pd" + +vtestnzcpd :: Ext.T (V2Double -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestnzcpd = Ext.intrinsic ExtX86.avx "vtestnzc.pd" + +vtestzps :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestzps = Ext.intrinsic ExtX86.avx "vtestz.ps" + +vtestcps :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestcps = Ext.intrinsic ExtX86.avx "vtestc.ps" + +vtestnzcps :: Ext.T (V4Float -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestnzcps = Ext.intrinsic ExtX86.avx "vtestnzc.ps" + +vtestzpd256 :: Ext.T (V4Double -> V4Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestzpd256 = Ext.intrinsic ExtX86.avx "vtestz.pd.256" + +vtestcpd256 :: Ext.T (V4Double -> V4Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestcpd256 = Ext.intrinsic ExtX86.avx "vtestc.pd.256" + +vtestnzcpd256 :: Ext.T (V4Double -> V4Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestnzcpd256 = Ext.intrinsic ExtX86.avx "vtestnzc.pd.256" + +vtestzps256 :: Ext.T (V8Float -> V8Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestzps256 = Ext.intrinsic ExtX86.avx "vtestz.ps.256" + +vtestcps256 :: Ext.T (V8Float -> V8Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestcps256 = Ext.intrinsic ExtX86.avx "vtestc.ps.256" + +vtestnzcps256 :: Ext.T (V8Float -> V8Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +vtestnzcps256 = Ext.intrinsic ExtX86.avx "vtestnzc.ps.256" + +ptestz256 :: Ext.T (V4Int64 -> V4Int64 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ptestz256 = Ext.intrinsic ExtX86.avx "ptestz.256" + +ptestc256 :: Ext.T (V4Int64 -> V4Int64 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ptestc256 = Ext.intrinsic ExtX86.avx "ptestc.256" + +ptestnzc256 :: Ext.T (V4Int64 -> V4Int64 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +ptestnzc256 = Ext.intrinsic ExtX86.avx "ptestnzc.256" + +ptestmd512 :: Ext.T (V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (LLVM.Value I.Int16)) +ptestmd512 = Ext.intrinsic ExtX86.avx512 "mask.ptestm.d.512" + +ptestmq512 :: Ext.T (V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int8)) +ptestmq512 = Ext.intrinsic ExtX86.avx512 "mask.ptestm.q.512" + +fpclasspd128_mask :: Ext.T (V2Double -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int8)) +fpclasspd128_mask = Ext.intrinsic ExtX86.avx512 "mask.fpclass.pd.128" + +fpclasspd256_mask :: Ext.T (V4Double -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int8)) +fpclasspd256_mask = Ext.intrinsic ExtX86.avx512 "mask.fpclass.pd.256" + +fpclasspd512_mask :: Ext.T (V8Double -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int8)) +fpclasspd512_mask = Ext.intrinsic ExtX86.avx512 "mask.fpclass.pd.512" + +fpclassps128_mask :: Ext.T (V4Float -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int8)) +fpclassps128_mask = Ext.intrinsic ExtX86.avx512 "mask.fpclass.ps.128" + +fpclassps256_mask :: Ext.T (V8Float -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int8)) +fpclassps256_mask = Ext.intrinsic ExtX86.avx512 "mask.fpclass.ps.256" + +fpclassps512_mask :: Ext.T (V16Float -> LLVM.Value I.Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (LLVM.Value I.Int16)) +fpclassps512_mask = Ext.intrinsic ExtX86.avx512 "mask.fpclass.ps.512" + +fpclasssd :: Ext.T (V2Double -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int8)) +fpclasssd = Ext.intrinsic ExtX86.avx512 "mask.fpclass.sd" + +fpclassss :: Ext.T (V4Float -> LLVM.Value I.Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int8)) +fpclassss = Ext.intrinsic ExtX86.avx512 "mask.fpclass.ss" + +movmskpd256 :: Ext.T (V4Double -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +movmskpd256 = Ext.intrinsic ExtX86.avx "movmsk.pd.256" + +movmskps256 :: Ext.T (V8Float -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +movmskps256 = Ext.intrinsic ExtX86.avx "movmsk.ps.256" + +vzeroall :: Ext.T (LLVM.CodeGenFunction r (LLVM.Value ())) +vzeroall = Ext.intrinsic ExtX86.avx "vzeroall" + +vzeroupper :: Ext.T (LLVM.CodeGenFunction r (LLVM.Value ())) +vzeroupper = Ext.intrinsic ExtX86.avx "vzeroupper" + +vbroadcastf128_pd256 :: Ext.T (LLVM.Value (Ptr ()) -> LLVM.CodeGenFunction r (V4Double)) +vbroadcastf128_pd256 = Ext.intrinsic ExtX86.avx "vbroadcastf128.pd.256" + +vbroadcastf128_ps256 :: Ext.T (LLVM.Value (Ptr ()) -> LLVM.CodeGenFunction r (V8Float)) +vbroadcastf128_ps256 = Ext.intrinsic ExtX86.avx "vbroadcastf128.ps.256" + +lddqu256 :: Ext.T (LLVM.Value (Ptr ()) -> LLVM.CodeGenFunction r (V32Int8)) +lddqu256 = Ext.intrinsic ExtX86.avx "ldu.dq.256" + +storeupd256 :: Ext.T (LLVM.Value (Ptr ()) -> V4Double -> LLVM.CodeGenFunction r (LLVM.Value ())) +storeupd256 = Ext.intrinsic ExtX86.avx "storeu.pd.256" + +storeups256 :: Ext.T (LLVM.Value (Ptr ()) -> V8Float -> LLVM.CodeGenFunction r (LLVM.Value ())) +storeups256 = Ext.intrinsic ExtX86.avx "storeu.ps.256" + +storedqu256 :: Ext.T (LLVM.Value (Ptr ()) -> V32Int8 -> LLVM.CodeGenFunction r (LLVM.Value ())) +storedqu256 = Ext.intrinsic ExtX86.avx "storeu.dq.256" + +maskloadpd :: Ext.T (LLVM.Value (Ptr ()) -> V2Int64 -> LLVM.CodeGenFunction r (V2Double)) +maskloadpd = Ext.intrinsic ExtX86.avx "maskload.pd" + +maskloadps :: Ext.T (LLVM.Value (Ptr ()) -> V4Int32 -> LLVM.CodeGenFunction r (V4Float)) +maskloadps = Ext.intrinsic ExtX86.avx "maskload.ps" + +maskloadpd256 :: Ext.T (LLVM.Value (Ptr ()) -> V4Int64 -> LLVM.CodeGenFunction r (V4Double)) +maskloadpd256 = Ext.intrinsic ExtX86.avx "maskload.pd.256" + +maskloadps256 :: Ext.T (LLVM.Value (Ptr ()) -> V8Int32 -> LLVM.CodeGenFunction r (V8Float)) +maskloadps256 = Ext.intrinsic ExtX86.avx "maskload.ps.256" + +loadups128_mask :: Ext.T (LLVM.Value (Ptr ()) -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +loadups128_mask = Ext.intrinsic ExtX86.avx512 "mask.loadu.ps.128" + +loadups256_mask :: Ext.T (LLVM.Value (Ptr ()) -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +loadups256_mask = Ext.intrinsic ExtX86.avx512 "mask.loadu.ps.256" + +loadups512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +loadups512_mask = Ext.intrinsic ExtX86.avx512 "mask.loadu.ps.512" + +loadupd128_mask :: Ext.T (LLVM.Value (Ptr ()) -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +loadupd128_mask = Ext.intrinsic ExtX86.avx512 "mask.loadu.pd.128" + +loadupd256_mask :: Ext.T (LLVM.Value (Ptr ()) -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +loadupd256_mask = Ext.intrinsic ExtX86.avx512 "mask.loadu.pd.256" + +loadupd512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +loadupd512_mask = Ext.intrinsic ExtX86.avx512 "mask.loadu.pd.512" + +loadaps128_mask :: Ext.T (LLVM.Value (Ptr ()) -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +loadaps128_mask = Ext.intrinsic ExtX86.avx512 "mask.load.ps.128" + +loadaps256_mask :: Ext.T (LLVM.Value (Ptr ()) -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +loadaps256_mask = Ext.intrinsic ExtX86.avx512 "mask.load.ps.256" + +loadaps512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +loadaps512_mask = Ext.intrinsic ExtX86.avx512 "mask.load.ps.512" + +loadapd128_mask :: Ext.T (LLVM.Value (Ptr ()) -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +loadapd128_mask = Ext.intrinsic ExtX86.avx512 "mask.load.pd.128" + +loadapd256_mask :: Ext.T (LLVM.Value (Ptr ()) -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +loadapd256_mask = Ext.intrinsic ExtX86.avx512 "mask.load.pd.256" + +loadapd512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +loadapd512_mask = Ext.intrinsic ExtX86.avx512 "mask.load.pd.512" + +movss_mask :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +movss_mask = Ext.intrinsic ExtX86.avx512 "mask.move.ss" + +movsd_mask :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +movsd_mask = Ext.intrinsic ExtX86.avx512 "mask.move.sd" + +maskstorepd :: Ext.T (LLVM.Value (Ptr ()) -> V2Int64 -> V2Double -> LLVM.CodeGenFunction r (LLVM.Value ())) +maskstorepd = Ext.intrinsic ExtX86.avx "maskstore.pd" + +maskstoreps :: Ext.T (LLVM.Value (Ptr ()) -> V4Int32 -> V4Float -> LLVM.CodeGenFunction r (LLVM.Value ())) +maskstoreps = Ext.intrinsic ExtX86.avx "maskstore.ps" + +maskstorepd256 :: Ext.T (LLVM.Value (Ptr ()) -> V4Int64 -> V4Double -> LLVM.CodeGenFunction r (LLVM.Value ())) +maskstorepd256 = Ext.intrinsic ExtX86.avx "maskstore.pd.256" + +maskstoreps256 :: Ext.T (LLVM.Value (Ptr ()) -> V8Int32 -> V8Float -> LLVM.CodeGenFunction r (LLVM.Value ())) +maskstoreps256 = Ext.intrinsic ExtX86.avx "maskstore.ps.256" + +storeups512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (LLVM.Value ())) +storeups512_mask = Ext.intrinsic ExtX86.avx512 "mask.storeu.ps.512" + +storeupd512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value ())) +storeupd512_mask = Ext.intrinsic ExtX86.avx512 "mask.storeu.pd.512" + +storeaps512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (LLVM.Value ())) +storeaps512_mask = Ext.intrinsic ExtX86.avx512 "mask.store.ps.512" + +storeapd512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value ())) +storeapd512_mask = Ext.intrinsic ExtX86.avx512 "mask.store.pd.512" + +storess_mask :: Ext.T (LLVM.Value (Ptr ()) -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value ())) +storess_mask = Ext.intrinsic ExtX86.avx512 "mask.store.ss" + +paddsb256 :: Ext.T (V32Int8 -> V32Int8 -> LLVM.CodeGenFunction r (V32Int8)) +paddsb256 = Ext.intrinsic ExtX86.avx2 "padds.b" + +paddsw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +paddsw256 = Ext.intrinsic ExtX86.avx2 "padds.w" + +paddusb256 :: Ext.T (V32Word8 -> V32Word8 -> LLVM.CodeGenFunction r (V32Word8)) +paddusb256 = Ext.intrinsic ExtX86.avx2 "paddus.b" + +paddusw256 :: Ext.T (V16Word16 -> V16Word16 -> LLVM.CodeGenFunction r (V16Word16)) +paddusw256 = Ext.intrinsic ExtX86.avx2 "paddus.w" + +psubsb256 :: Ext.T (V32Int8 -> V32Int8 -> LLVM.CodeGenFunction r (V32Int8)) +psubsb256 = Ext.intrinsic ExtX86.avx2 "psubs.b" + +psubsw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psubsw256 = Ext.intrinsic ExtX86.avx2 "psubs.w" + +psubusb256 :: Ext.T (V32Word8 -> V32Word8 -> LLVM.CodeGenFunction r (V32Word8)) +psubusb256 = Ext.intrinsic ExtX86.avx2 "psubus.b" + +psubusw256 :: Ext.T (V16Word16 -> V16Word16 -> LLVM.CodeGenFunction r (V16Word16)) +psubusw256 = Ext.intrinsic ExtX86.avx2 "psubus.w" + +pmulhuw256 :: Ext.T (V16Word16 -> V16Word16 -> LLVM.CodeGenFunction r (V16Word16)) +pmulhuw256 = Ext.intrinsic ExtX86.avx2 "pmulhu.w" + +pmulhw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pmulhw256 = Ext.intrinsic ExtX86.avx2 "pmulh.w" + +pmuludq256 :: Ext.T (V8Word32 -> V8Word32 -> LLVM.CodeGenFunction r (V4Word64)) +pmuludq256 = Ext.intrinsic ExtX86.avx2 "pmulu.dq" + +pmuldq256 :: Ext.T (V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (V4Int64)) +pmuldq256 = Ext.intrinsic ExtX86.avx2 "pmul.dq" + +pmaddwd256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V8Int32)) +pmaddwd256 = Ext.intrinsic ExtX86.avx2 "pmadd.wd" + +pavgb256 :: Ext.T (V32Int8 -> V32Int8 -> LLVM.CodeGenFunction r (V32Int8)) +pavgb256 = Ext.intrinsic ExtX86.avx2 "pavg.b" + +pavgw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pavgw256 = Ext.intrinsic ExtX86.avx2 "pavg.w" + +psadbw256 :: Ext.T (V32Int8 -> V32Int8 -> LLVM.CodeGenFunction r (V4Int64)) +psadbw256 = Ext.intrinsic ExtX86.avx2 "psad.bw" + +pmaxub256 :: Ext.T (V32Word8 -> V32Word8 -> LLVM.CodeGenFunction r (V32Word8)) +pmaxub256 = Ext.intrinsic ExtX86.avx2 "pmaxu.b" + +pmaxuw256 :: Ext.T (V16Word16 -> V16Word16 -> LLVM.CodeGenFunction r (V16Word16)) +pmaxuw256 = Ext.intrinsic ExtX86.avx2 "pmaxu.w" + +pmaxud256 :: Ext.T (V8Word32 -> V8Word32 -> LLVM.CodeGenFunction r (V8Word32)) +pmaxud256 = Ext.intrinsic ExtX86.avx2 "pmaxu.d" + +pmaxsb256 :: Ext.T (V32Int8 -> V32Int8 -> LLVM.CodeGenFunction r (V32Int8)) +pmaxsb256 = Ext.intrinsic ExtX86.avx2 "pmaxs.b" + +pmaxsw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pmaxsw256 = Ext.intrinsic ExtX86.avx2 "pmaxs.w" + +pmaxsd256 :: Ext.T (V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (V8Int32)) +pmaxsd256 = Ext.intrinsic ExtX86.avx2 "pmaxs.d" + +pminub256 :: Ext.T (V32Word8 -> V32Word8 -> LLVM.CodeGenFunction r (V32Word8)) +pminub256 = Ext.intrinsic ExtX86.avx2 "pminu.b" + +pminuw256 :: Ext.T (V16Word16 -> V16Word16 -> LLVM.CodeGenFunction r (V16Word16)) +pminuw256 = Ext.intrinsic ExtX86.avx2 "pminu.w" + +pminud256 :: Ext.T (V8Word32 -> V8Word32 -> LLVM.CodeGenFunction r (V8Word32)) +pminud256 = Ext.intrinsic ExtX86.avx2 "pminu.d" + +pminsb256 :: Ext.T (V32Int8 -> V32Int8 -> LLVM.CodeGenFunction r (V32Int8)) +pminsb256 = Ext.intrinsic ExtX86.avx2 "pmins.b" + +pminsw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pminsw256 = Ext.intrinsic ExtX86.avx2 "pmins.w" + +pminsd256 :: Ext.T (V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (V8Int32)) +pminsd256 = Ext.intrinsic ExtX86.avx2 "pmins.d" + +pmaxsb128_mask :: Ext.T (V16Int8 -> V16Int8 -> V16Int8 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int8)) +pmaxsb128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.b.128" + +pmaxsb256_mask :: Ext.T (V32Int8 -> V32Int8 -> V32Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int8)) +pmaxsb256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.b.256" + +pmaxsb512_mask :: Ext.T (V64Int8 -> V64Int8 -> V64Int8 -> LLVM.Value I.Int64 -> LLVM.CodeGenFunction r (V64Int8)) +pmaxsb512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.b.512" + +pmaxub128_mask :: Ext.T (V16Int8 -> V16Int8 -> V16Int8 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int8)) +pmaxub128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.b.128" + +pmaxub256_mask :: Ext.T (V32Int8 -> V32Int8 -> V32Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int8)) +pmaxub256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.b.256" + +pmaxub512_mask :: Ext.T (V64Int8 -> V64Int8 -> V64Int8 -> LLVM.Value I.Int64 -> LLVM.CodeGenFunction r (V64Int8)) +pmaxub512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.b.512" + +pmaxsw128_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pmaxsw128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.w.128" + +pmaxsw256_mask :: Ext.T (V16Int16 -> V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pmaxsw256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.w.256" + +pmaxsw512_mask :: Ext.T (V32Int16 -> V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +pmaxsw512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.w.512" + +pmaxuw128_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pmaxuw128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.w.128" + +pmaxuw256_mask :: Ext.T (V16Int16 -> V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pmaxuw256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.w.256" + +pmaxuw512_mask :: Ext.T (V32Int16 -> V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +pmaxuw512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.w.512" + +pminsb128_mask :: Ext.T (V16Int8 -> V16Int8 -> V16Int8 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int8)) +pminsb128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.b.128" + +pminsb256_mask :: Ext.T (V32Int8 -> V32Int8 -> V32Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int8)) +pminsb256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.b.256" + +pminsb512_mask :: Ext.T (V64Int8 -> V64Int8 -> V64Int8 -> LLVM.Value I.Int64 -> LLVM.CodeGenFunction r (V64Int8)) +pminsb512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.b.512" + +pminub128_mask :: Ext.T (V16Int8 -> V16Int8 -> V16Int8 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int8)) +pminub128_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.b.128" + +pminub256_mask :: Ext.T (V32Int8 -> V32Int8 -> V32Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int8)) +pminub256_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.b.256" + +pminub512_mask :: Ext.T (V64Int8 -> V64Int8 -> V64Int8 -> LLVM.Value I.Int64 -> LLVM.CodeGenFunction r (V64Int8)) +pminub512_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.b.512" + +pminsw128_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pminsw128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.w.128" + +pminsw256_mask :: Ext.T (V16Int16 -> V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pminsw256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.w.256" + +pminsw512_mask :: Ext.T (V32Int16 -> V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +pminsw512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.w.512" + +pminuw128_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pminuw128_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.w.128" + +pminuw256_mask :: Ext.T (V16Int16 -> V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pminuw256_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.w.256" + +pminuw512_mask :: Ext.T (V32Int16 -> V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +pminuw512_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.w.512" + +pmaxud512_mask :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +pmaxud512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.d.512" + +pmaxud256_mask :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +pmaxud256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.d.256" + +pmaxud128_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +pmaxud128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.d.128" + +pmaxsd512_mask :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +pmaxsd512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.d.512" + +pmaxsd256_mask :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +pmaxsd256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.d.256" + +pmaxsd128_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +pmaxsd128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.d.128" + +pmaxuq512_mask :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +pmaxuq512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.q.512" + +pmaxuq256_mask :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +pmaxuq256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.q.256" + +pmaxuq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +pmaxuq128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxu.q.128" + +pmaxsq512_mask :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +pmaxsq512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.q.512" + +pmaxsq256_mask :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +pmaxsq256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.q.256" + +pmaxsq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +pmaxsq128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmaxs.q.128" + +pminud512_mask :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +pminud512_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.d.512" + +pminud256_mask :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +pminud256_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.d.256" + +pminud128_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +pminud128_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.d.128" + +pminsd512_mask :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +pminsd512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.d.512" + +pminsd256_mask :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +pminsd256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.d.256" + +pminsd128_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +pminsd128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.d.128" + +pminuq512_mask :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +pminuq512_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.q.512" + +pminuq256_mask :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +pminuq256_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.q.256" + +pminuq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +pminuq128_mask = Ext.intrinsic ExtX86.avx512 "mask.pminu.q.128" + +pminsq512_mask :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +pminsq512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.q.512" + +pminsq256_mask :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +pminsq256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.q.256" + +pminsq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +pminsq128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmins.q.128" + +psllw256 :: Ext.T (V16Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psllw256 = Ext.intrinsic ExtX86.avx2 "psll.w" + +pslld256 :: Ext.T (V8Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V8Int32)) +pslld256 = Ext.intrinsic ExtX86.avx2 "psll.d" + +psllq256 :: Ext.T (V4Int64 -> V2Int64 -> LLVM.CodeGenFunction r (V4Int64)) +psllq256 = Ext.intrinsic ExtX86.avx2 "psll.q" + +psrlw256 :: Ext.T (V16Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psrlw256 = Ext.intrinsic ExtX86.avx2 "psrl.w" + +psrld256 :: Ext.T (V8Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V8Int32)) +psrld256 = Ext.intrinsic ExtX86.avx2 "psrl.d" + +psrlq256 :: Ext.T (V4Int64 -> V2Int64 -> LLVM.CodeGenFunction r (V4Int64)) +psrlq256 = Ext.intrinsic ExtX86.avx2 "psrl.q" + +psraw256 :: Ext.T (V16Int16 -> V8Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psraw256 = Ext.intrinsic ExtX86.avx2 "psra.w" + +psrad256 :: Ext.T (V8Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V8Int32)) +psrad256 = Ext.intrinsic ExtX86.avx2 "psra.d" + +psllwi256 :: Ext.T (V16Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Int16)) +psllwi256 = Ext.intrinsic ExtX86.avx2 "pslli.w" + +pslldi256 :: Ext.T (V8Int32 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Int32)) +pslldi256 = Ext.intrinsic ExtX86.avx2 "pslli.d" + +psllqi256 :: Ext.T (V4Int64 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V4Int64)) +psllqi256 = Ext.intrinsic ExtX86.avx2 "pslli.q" + +psrlwi256 :: Ext.T (V16Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Int16)) +psrlwi256 = Ext.intrinsic ExtX86.avx2 "psrli.w" + +psrldi256 :: Ext.T (V8Int32 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Int32)) +psrldi256 = Ext.intrinsic ExtX86.avx2 "psrli.d" + +psrlqi256 :: Ext.T (V4Int64 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V4Int64)) +psrlqi256 = Ext.intrinsic ExtX86.avx2 "psrli.q" + +psrawi256 :: Ext.T (V16Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Int16)) +psrawi256 = Ext.intrinsic ExtX86.avx2 "psrai.w" + +psradi256 :: Ext.T (V8Int32 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Int32)) +psradi256 = Ext.intrinsic ExtX86.avx2 "psrai.d" + +pslldi512 :: Ext.T (V16Int32 -> LLVM.Value I.Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +pslldi512 = Ext.intrinsic ExtX86.avx512 "mask.pslli.d" + +psllqi512 :: Ext.T (V8Int64 -> LLVM.Value I.Int32 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psllqi512 = Ext.intrinsic ExtX86.avx512 "mask.pslli.q" + +psrldi512 :: Ext.T (V16Int32 -> LLVM.Value I.Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +psrldi512 = Ext.intrinsic ExtX86.avx512 "mask.psrli.d" + +psrlqi512 :: Ext.T (V8Int64 -> LLVM.Value I.Int32 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psrlqi512 = Ext.intrinsic ExtX86.avx512 "mask.psrli.q" + +psradi512 :: Ext.T (V16Int32 -> LLVM.Value I.Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +psradi512 = Ext.intrinsic ExtX86.avx512 "mask.psrai.d" + +psraqi512 :: Ext.T (V8Int64 -> LLVM.Value I.Int32 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psraqi512 = Ext.intrinsic ExtX86.avx512 "mask.psrai.q" + +psrlw128_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +psrlw128_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.w.128" + +psrlw256_mask :: Ext.T (V16Int16 -> V8Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psrlw256_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.w.256" + +psrlw512_mask :: Ext.T (V32Int16 -> V8Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +psrlw512_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.w.512" + +psrlwi128_mask :: Ext.T (V8Int16 -> LLVM.Value I.Int8 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +psrlwi128_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.wi.128" + +psrlwi256_mask :: Ext.T (V16Int16 -> LLVM.Value I.Int8 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psrlwi256_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.wi.256" + +psrlwi512_mask :: Ext.T (V32Int16 -> LLVM.Value I.Int8 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +psrlwi512_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.wi.512" + +psraw128_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +psraw128_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.w.128" + +psraw256_mask :: Ext.T (V16Int16 -> V8Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psraw256_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.w.256" + +psraw512_mask :: Ext.T (V32Int16 -> V8Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +psraw512_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.w.512" + +psrawi128_mask :: Ext.T (V8Int16 -> LLVM.Value I.Int8 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +psrawi128_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.wi.128" + +psrawi256_mask :: Ext.T (V16Int16 -> LLVM.Value I.Int8 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psrawi256_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.wi.256" + +psrawi512_mask :: Ext.T (V32Int16 -> LLVM.Value I.Int8 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +psrawi512_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.wi.512" + +pslld512_mask :: Ext.T (V16Int32 -> V4Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +pslld512_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.d" + +psllq512_mask :: Ext.T (V8Int64 -> V2Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psllq512_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.q" + +psrld512_mask :: Ext.T (V16Int32 -> V4Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +psrld512_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.d" + +psrlq512_mask :: Ext.T (V8Int64 -> V2Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psrlq512_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.q" + +psrad512_mask :: Ext.T (V16Int32 -> V4Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +psrad512_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.d" + +psraq512_mask :: Ext.T (V8Int64 -> V2Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psraq512_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.q" + +psllw128_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +psllw128_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.w.128" + +psllw256_mask :: Ext.T (V16Int16 -> V8Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psllw256_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.w.256" + +psllw512_mask :: Ext.T (V32Int16 -> V8Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +psllw512_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.w.512" + +psllwi128_mask :: Ext.T (V8Int16 -> LLVM.Value I.Int8 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +psllwi128_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.wi.128" + +psllwi256_mask :: Ext.T (V16Int16 -> LLVM.Value I.Int8 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psllwi256_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.wi.256" + +psllwi512_mask :: Ext.T (V32Int16 -> LLVM.Value I.Int8 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +psllwi512_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.wi.512" + +psllv16hi_mask :: Ext.T (V16Int16 -> V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psllv16hi_mask = Ext.intrinsic ExtX86.avx512 "mask.psllv16.hi" + +psllv2di_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +psllv2di_mask = Ext.intrinsic ExtX86.avx512 "mask.psllv2.di" + +psllv32hi_mask :: Ext.T (V32Int16 -> V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +psllv32hi_mask = Ext.intrinsic ExtX86.avx512 "mask.psllv32hi" + +psllv4di_mask :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +psllv4di_mask = Ext.intrinsic ExtX86.avx512 "mask.psllv4.di" + +psllv4si_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +psllv4si_mask = Ext.intrinsic ExtX86.avx512 "mask.psllv4.si" + +psllv8hi_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +psllv8hi_mask = Ext.intrinsic ExtX86.avx512 "mask.psllv8.hi" + +psllv8si_mask :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +psllv8si_mask = Ext.intrinsic ExtX86.avx512 "mask.psllv8.si" + +psrad128_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +psrad128_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.d.128" + +psrad256_mask :: Ext.T (V8Int32 -> V4Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +psrad256_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.d.256" + +psradi128_mask :: Ext.T (V4Int32 -> LLVM.Value I.Int8 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +psradi128_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.di.128" + +psradi256_mask :: Ext.T (V8Int32 -> LLVM.Value I.Int8 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +psradi256_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.di.256" + +psradi512_mask :: Ext.T (V16Int32 -> LLVM.Value I.Int8 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +psradi512_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.di.512" + +psraq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +psraq128_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.q.128" + +psraq256_mask :: Ext.T (V4Int64 -> V2Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +psraq256_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.q.256" + +psraqi128_mask :: Ext.T (V2Int64 -> LLVM.Value I.Int8 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +psraqi128_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.qi.128" + +psraqi256_mask :: Ext.T (V4Int64 -> LLVM.Value I.Int8 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +psraqi256_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.qi.256" + +psraqi512_mask :: Ext.T (V8Int64 -> LLVM.Value I.Int8 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psraqi512_mask = Ext.intrinsic ExtX86.avx512 "mask.psra.qi.512" + +psrld128_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +psrld128_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.d.128" + +psrld256_mask :: Ext.T (V8Int32 -> V4Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +psrld256_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.d.256" + +psrldi128_mask :: Ext.T (V4Int32 -> LLVM.Value I.Int8 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +psrldi128_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.di.128" + +psrldi256_mask :: Ext.T (V8Int32 -> LLVM.Value I.Int8 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +psrldi256_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.di.256" + +psrldi512_mask :: Ext.T (V16Int32 -> LLVM.Value I.Int8 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +psrldi512_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.di.512" + +psrlq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +psrlq128_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.q.128" + +psrlq256_mask :: Ext.T (V4Int64 -> V2Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +psrlq256_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.q.256" + +psrlqi128_mask :: Ext.T (V2Int64 -> LLVM.Value I.Int8 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +psrlqi128_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.qi.128" + +psrlqi256_mask :: Ext.T (V4Int64 -> LLVM.Value I.Int8 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +psrlqi256_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.qi.256" + +psrlqi512_mask :: Ext.T (V8Int64 -> LLVM.Value I.Int8 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psrlqi512_mask = Ext.intrinsic ExtX86.avx512 "mask.psrl.qi.512" + +packsswb256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V32Int8)) +packsswb256 = Ext.intrinsic ExtX86.avx2 "packsswb" + +packssdw256 :: Ext.T (V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (V16Int16)) +packssdw256 = Ext.intrinsic ExtX86.avx2 "packssdw" + +packuswb256 :: Ext.T (V16Word16 -> V16Word16 -> LLVM.CodeGenFunction r (V32Word8)) +packuswb256 = Ext.intrinsic ExtX86.avx2 "packuswb" + +packusdw256 :: Ext.T (V8Word32 -> V8Word32 -> LLVM.CodeGenFunction r (V16Word16)) +packusdw256 = Ext.intrinsic ExtX86.avx2 "packusdw" + +pabsb256 :: Ext.T (V32Int8 -> LLVM.CodeGenFunction r (V32Int8)) +pabsb256 = Ext.intrinsic ExtX86.avx2 "pabs.b" + +pabsw256 :: Ext.T (V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pabsw256 = Ext.intrinsic ExtX86.avx2 "pabs.w" + +pabsd256 :: Ext.T (V8Int32 -> LLVM.CodeGenFunction r (V8Int32)) +pabsd256 = Ext.intrinsic ExtX86.avx2 "pabs.d" + +pabsb128_mask :: Ext.T (V16Int8 -> V16Int8 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int8)) +pabsb128_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.b.128" + +pabsb256_mask :: Ext.T (V32Int8 -> V32Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int8)) +pabsb256_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.b.256" + +pabsb512_mask :: Ext.T (V64Int8 -> V64Int8 -> LLVM.Value I.Int64 -> LLVM.CodeGenFunction r (V64Int8)) +pabsb512_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.b.512" + +pabsd128_mask :: Ext.T (V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +pabsd128_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.d.128" + +pabsd256_mask :: Ext.T (V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +pabsd256_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.d.256" + +pabsd512_mask :: Ext.T (V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +pabsd512_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.d.512" + +pabsq128_mask :: Ext.T (V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +pabsq128_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.q.128" + +pabsq256_mask :: Ext.T (V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +pabsq256_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.q.256" + +pabsq512_mask :: Ext.T (V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +pabsq512_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.q.512" + +pabsw128_mask :: Ext.T (V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pabsw128_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.w.128" + +pabsw256_mask :: Ext.T (V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pabsw256_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.w.256" + +pabsw512_mask :: Ext.T (V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +pabsw512_mask = Ext.intrinsic ExtX86.avx512 "mask.pabs.w.512" + +phaddw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +phaddw256 = Ext.intrinsic ExtX86.avx2 "phadd.w" + +phaddd256 :: Ext.T (V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (V8Int32)) +phaddd256 = Ext.intrinsic ExtX86.avx2 "phadd.d" + +phaddsw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +phaddsw256 = Ext.intrinsic ExtX86.avx2 "phadd.sw" + +phsubw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +phsubw256 = Ext.intrinsic ExtX86.avx2 "phsub.w" + +phsubd256 :: Ext.T (V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (V8Int32)) +phsubd256 = Ext.intrinsic ExtX86.avx2 "phsub.d" + +phsubsw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +phsubsw256 = Ext.intrinsic ExtX86.avx2 "phsub.sw" + +pmaddubsw256 :: Ext.T (V32Word8 -> V32Word8 -> LLVM.CodeGenFunction r (V16Word16)) +pmaddubsw256 = Ext.intrinsic ExtX86.avx2 "pmadd.ub.sw" + +psignb256 :: Ext.T (V32Int8 -> V32Int8 -> LLVM.CodeGenFunction r (V32Int8)) +psignb256 = Ext.intrinsic ExtX86.avx2 "psign.b" + +psignw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psignw256 = Ext.intrinsic ExtX86.avx2 "psign.w" + +psignd256 :: Ext.T (V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (V8Int32)) +psignd256 = Ext.intrinsic ExtX86.avx2 "psign.d" + +pmulhrsw256 :: Ext.T (V16Int16 -> V16Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pmulhrsw256 = Ext.intrinsic ExtX86.avx2 "pmul.hr.sw" + +pmulhrsw128_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +pmulhrsw128_mask = Ext.intrinsic ExtX86.avx512 "mask.pmul.hr.sw.128" + +pmulhrsw256_mask :: Ext.T (V16Int16 -> V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +pmulhrsw256_mask = Ext.intrinsic ExtX86.avx512 "mask.pmul.hr.sw.256" + +pmulhrsw512_mask :: Ext.T (V32Int16 -> V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +pmulhrsw512_mask = Ext.intrinsic ExtX86.avx512 "mask.pmul.hr.sw.512" + +pmovsxbd256 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V8Int32)) +pmovsxbd256 = Ext.intrinsic ExtX86.avx2 "pmovsxbd" + +pmovsxbq256 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V4Int64)) +pmovsxbq256 = Ext.intrinsic ExtX86.avx2 "pmovsxbq" + +pmovsxbw256 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V16Int16)) +pmovsxbw256 = Ext.intrinsic ExtX86.avx2 "pmovsxbw" + +pmovsxdq256 :: Ext.T (V4Int32 -> LLVM.CodeGenFunction r (V4Int64)) +pmovsxdq256 = Ext.intrinsic ExtX86.avx2 "pmovsxdq" + +pmovsxwd256 :: Ext.T (V8Int16 -> LLVM.CodeGenFunction r (V8Int32)) +pmovsxwd256 = Ext.intrinsic ExtX86.avx2 "pmovsxwd" + +pmovsxwq256 :: Ext.T (V8Int16 -> LLVM.CodeGenFunction r (V4Int64)) +pmovsxwq256 = Ext.intrinsic ExtX86.avx2 "pmovsxwq" + +pmovzxbd256 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V8Int32)) +pmovzxbd256 = Ext.intrinsic ExtX86.avx2 "pmovzxbd" + +pmovzxbq256 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V4Int64)) +pmovzxbq256 = Ext.intrinsic ExtX86.avx2 "pmovzxbq" + +pmovzxbw256 :: Ext.T (V16Int8 -> LLVM.CodeGenFunction r (V16Int16)) +pmovzxbw256 = Ext.intrinsic ExtX86.avx2 "pmovzxbw" + +pmovzxdq256 :: Ext.T (V4Int32 -> LLVM.CodeGenFunction r (V4Int64)) +pmovzxdq256 = Ext.intrinsic ExtX86.avx2 "pmovzxdq" + +pmovzxwd256 :: Ext.T (V8Int16 -> LLVM.CodeGenFunction r (V8Int32)) +pmovzxwd256 = Ext.intrinsic ExtX86.avx2 "pmovzxwd" + +pmovzxwq256 :: Ext.T (V8Int16 -> LLVM.CodeGenFunction r (V4Int64)) +pmovzxwq256 = Ext.intrinsic ExtX86.avx2 "pmovzxwq" + +pblendvb256 :: Ext.T (V32Int8 -> V32Int8 -> V32Int8 -> LLVM.CodeGenFunction r (V32Int8)) +pblendvb256 = Ext.intrinsic ExtX86.avx2 "pblendvb" + +pbroadcastd512_gpr_mask :: Ext.T (LLVM.Value I.Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +pbroadcastd512_gpr_mask = Ext.intrinsic ExtX86.avx512 "mask.pbroadcast.d.gpr.512" + +pbroadcastq512_gpr_mask :: Ext.T (LLVM.Value I.Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +pbroadcastq512_gpr_mask = Ext.intrinsic ExtX86.avx512 "mask.pbroadcast.q.gpr.512" + +pbroadcastq512_mem_mask :: Ext.T (LLVM.Value I.Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +pbroadcastq512_mem_mask = Ext.intrinsic ExtX86.avx512 "mask.pbroadcast.q.mem.512" + +permvarsi256 :: Ext.T (V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (V8Int32)) +permvarsi256 = Ext.intrinsic ExtX86.avx2 "permd" + +permvarsf256 :: Ext.T (V8Float -> V8Int32 -> LLVM.CodeGenFunction r (V8Float)) +permvarsf256 = Ext.intrinsic ExtX86.avx2 "permps" + +permti256 :: Ext.T (V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +permti256 = Ext.intrinsic ExtX86.avx2 "vperm2i128" + +extractf32x4_mask :: Ext.T (V16Float -> LLVM.Value I.Int32 -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +extractf32x4_mask = Ext.intrinsic ExtX86.avx512 "mask.vextractf32x4.512" + +extracti32x4_mask :: Ext.T (V16Int32 -> LLVM.Value I.Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +extracti32x4_mask = Ext.intrinsic ExtX86.avx512 "mask.vextracti32x4.512" + +extractf32x4_256_mask :: Ext.T (V8Float -> LLVM.Value I.Int32 -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +extractf32x4_256_mask = Ext.intrinsic ExtX86.avx512 "mask.vextractf32x4.256" + +extracti32x4_256_mask :: Ext.T (V8Int32 -> LLVM.Value I.Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +extracti32x4_256_mask = Ext.intrinsic ExtX86.avx512 "mask.vextracti32x4.256" + +extractf64x2_256_mask :: Ext.T (V4Double -> LLVM.Value I.Int32 -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +extractf64x2_256_mask = Ext.intrinsic ExtX86.avx512 "mask.vextractf64x2.256" + +extracti64x2_256_mask :: Ext.T (V4Int64 -> LLVM.Value I.Int32 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +extracti64x2_256_mask = Ext.intrinsic ExtX86.avx512 "mask.vextracti64x2.256" + +extractf64x2_512_mask :: Ext.T (V8Double -> LLVM.Value I.Int32 -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +extractf64x2_512_mask = Ext.intrinsic ExtX86.avx512 "mask.vextractf64x2.512" + +extracti64x2_512_mask :: Ext.T (V8Int64 -> LLVM.Value I.Int32 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +extracti64x2_512_mask = Ext.intrinsic ExtX86.avx512 "mask.vextracti64x2.512" + +extractf32x8_mask :: Ext.T (V16Float -> LLVM.Value I.Int32 -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +extractf32x8_mask = Ext.intrinsic ExtX86.avx512 "mask.vextractf32x8.512" + +extracti32x8_mask :: Ext.T (V16Int32 -> LLVM.Value I.Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +extracti32x8_mask = Ext.intrinsic ExtX86.avx512 "mask.vextracti32x8.512" + +extractf64x4_mask :: Ext.T (V8Double -> LLVM.Value I.Int32 -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +extractf64x4_mask = Ext.intrinsic ExtX86.avx512 "mask.vextractf64x4.512" + +extracti64x4_mask :: Ext.T (V8Int64 -> LLVM.Value I.Int32 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +extracti64x4_mask = Ext.intrinsic ExtX86.avx512 "mask.vextracti64x4.512" + +insertf32x4_256_mask :: Ext.T (V8Float -> V4Float -> LLVM.Value I.Int32 -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +insertf32x4_256_mask = Ext.intrinsic ExtX86.avx512 "mask.insertf32x4.256" + +insertf32x4_512_mask :: Ext.T (V16Float -> V4Float -> LLVM.Value I.Int32 -> V16Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V16Float)) +insertf32x4_512_mask = Ext.intrinsic ExtX86.avx512 "mask.insertf32x4.512" + +insertf32x8_mask :: Ext.T (V16Float -> V8Float -> LLVM.Value I.Int32 -> V16Float -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Float)) +insertf32x8_mask = Ext.intrinsic ExtX86.avx512 "mask.insertf32x8.512" + +insertf64x2_256_mask :: Ext.T (V4Double -> V2Double -> LLVM.Value I.Int32 -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +insertf64x2_256_mask = Ext.intrinsic ExtX86.avx512 "mask.insertf64x2.256" + +insertf64x2_512_mask :: Ext.T (V8Double -> V2Double -> LLVM.Value I.Int32 -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +insertf64x2_512_mask = Ext.intrinsic ExtX86.avx512 "mask.insertf64x2.512" + +insertf64x4_mask :: Ext.T (V8Double -> V4Double -> LLVM.Value I.Int32 -> V8Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Double)) +insertf64x4_mask = Ext.intrinsic ExtX86.avx512 "mask.insertf64x4.512" + +inserti32x4_256_mask :: Ext.T (V8Int32 -> V4Int32 -> LLVM.Value I.Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +inserti32x4_256_mask = Ext.intrinsic ExtX86.avx512 "mask.inserti32x4.256" + +inserti32x4_512_mask :: Ext.T (V16Int32 -> V4Int32 -> LLVM.Value I.Int32 -> V16Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V16Int32)) +inserti32x4_512_mask = Ext.intrinsic ExtX86.avx512 "mask.inserti32x4.512" + +inserti32x8_mask :: Ext.T (V16Int32 -> V8Int32 -> LLVM.Value I.Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +inserti32x8_mask = Ext.intrinsic ExtX86.avx512 "mask.inserti32x8.512" + +inserti64x2_256_mask :: Ext.T (V4Int64 -> V2Int64 -> LLVM.Value I.Int32 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +inserti64x2_256_mask = Ext.intrinsic ExtX86.avx512 "mask.inserti64x2.256" + +inserti64x2_512_mask :: Ext.T (V8Int64 -> V2Int64 -> LLVM.Value I.Int32 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +inserti64x2_512_mask = Ext.intrinsic ExtX86.avx512 "mask.inserti64x2.512" + +inserti64x4_mask :: Ext.T (V8Int64 -> V4Int64 -> LLVM.Value I.Int32 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +inserti64x4_mask = Ext.intrinsic ExtX86.avx512 "mask.inserti64x4.512" + +maskloadd :: Ext.T (LLVM.Value (Ptr ()) -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +maskloadd = Ext.intrinsic ExtX86.avx2 "maskload.d" + +maskloadq :: Ext.T (LLVM.Value (Ptr ()) -> V2Int64 -> LLVM.CodeGenFunction r (V2Int64)) +maskloadq = Ext.intrinsic ExtX86.avx2 "maskload.q" + +maskloadd256 :: Ext.T (LLVM.Value (Ptr ()) -> V8Int32 -> LLVM.CodeGenFunction r (V8Int32)) +maskloadd256 = Ext.intrinsic ExtX86.avx2 "maskload.d.256" + +maskloadq256 :: Ext.T (LLVM.Value (Ptr ()) -> V4Int64 -> LLVM.CodeGenFunction r (V4Int64)) +maskloadq256 = Ext.intrinsic ExtX86.avx2 "maskload.q.256" + +loaddqusi512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +loaddqusi512_mask = Ext.intrinsic ExtX86.avx512 "mask.loadu.d.512" + +loaddqudi512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +loaddqudi512_mask = Ext.intrinsic ExtX86.avx512 "mask.loadu.q.512" + +maskstored :: Ext.T (LLVM.Value (Ptr ()) -> V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (LLVM.Value ())) +maskstored = Ext.intrinsic ExtX86.avx2 "maskstore.d" + +maskstoreq :: Ext.T (LLVM.Value (Ptr ()) -> V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (LLVM.Value ())) +maskstoreq = Ext.intrinsic ExtX86.avx2 "maskstore.q" + +maskstored256 :: Ext.T (LLVM.Value (Ptr ()) -> V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (LLVM.Value ())) +maskstored256 = Ext.intrinsic ExtX86.avx2 "maskstore.d.256" + +maskstoreq256 :: Ext.T (LLVM.Value (Ptr ()) -> V4Int64 -> V4Int64 -> LLVM.CodeGenFunction r (LLVM.Value ())) +maskstoreq256 = Ext.intrinsic ExtX86.avx2 "maskstore.q.256" + +storedqusi512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (LLVM.Value ())) +storedqusi512_mask = Ext.intrinsic ExtX86.avx512 "mask.storeu.d.512" + +storedqudi512_mask :: Ext.T (LLVM.Value (Ptr ()) -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (LLVM.Value ())) +storedqudi512_mask = Ext.intrinsic ExtX86.avx512 "mask.storeu.q.512" + +psllv4si :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +psllv4si = Ext.intrinsic ExtX86.avx2 "psllv.d" + +psllv8si :: Ext.T (V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (V8Int32)) +psllv8si = Ext.intrinsic ExtX86.avx2 "psllv.d.256" + +psllv2di :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (V2Int64)) +psllv2di = Ext.intrinsic ExtX86.avx2 "psllv.q" + +psllv4di :: Ext.T (V4Int64 -> V4Int64 -> LLVM.CodeGenFunction r (V4Int64)) +psllv4di = Ext.intrinsic ExtX86.avx2 "psllv.q.256" + +psrlv4si :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +psrlv4si = Ext.intrinsic ExtX86.avx2 "psrlv.d" + +psrlv8si :: Ext.T (V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (V8Int32)) +psrlv8si = Ext.intrinsic ExtX86.avx2 "psrlv.d.256" + +psrlv2di :: Ext.T (V2Int64 -> V2Int64 -> LLVM.CodeGenFunction r (V2Int64)) +psrlv2di = Ext.intrinsic ExtX86.avx2 "psrlv.q" + +psrlv4di :: Ext.T (V4Int64 -> V4Int64 -> LLVM.CodeGenFunction r (V4Int64)) +psrlv4di = Ext.intrinsic ExtX86.avx2 "psrlv.q.256" + +psrav4si :: Ext.T (V4Int32 -> V4Int32 -> LLVM.CodeGenFunction r (V4Int32)) +psrav4si = Ext.intrinsic ExtX86.avx2 "psrav.d" + +psrav8si :: Ext.T (V8Int32 -> V8Int32 -> LLVM.CodeGenFunction r (V8Int32)) +psrav8si = Ext.intrinsic ExtX86.avx2 "psrav.d.256" + +psllv16si_mask :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +psllv16si_mask = Ext.intrinsic ExtX86.avx512 "mask.psllv.d" + +psllv8di_mask :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psllv8di_mask = Ext.intrinsic ExtX86.avx512 "mask.psllv.q" + +psrav16si_mask :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +psrav16si_mask = Ext.intrinsic ExtX86.avx512 "mask.psrav.d" + +psrav8di_mask :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psrav8di_mask = Ext.intrinsic ExtX86.avx512 "mask.psrav.q" + +psrlv16si_mask :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +psrlv16si_mask = Ext.intrinsic ExtX86.avx512 "mask.psrlv.d" + +psrlv8di_mask :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psrlv8di_mask = Ext.intrinsic ExtX86.avx512 "mask.psrlv.q" + +pslldq512 :: Ext.T (V8Int64 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Int64)) +pslldq512 = Ext.intrinsic ExtX86.avx512 "psll.dq.512" + +psrldq512 :: Ext.T (V8Int64 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Int64)) +psrldq512 = Ext.intrinsic ExtX86.avx512 "psrl.dq.512" + +pslld128_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +pslld128_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.d.128" + +pslld256_mask :: Ext.T (V8Int32 -> V4Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +pslld256_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.d.256" + +pslldi128_mask :: Ext.T (V4Int32 -> LLVM.Value I.Int8 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +pslldi128_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.di.128" + +pslldi256_mask :: Ext.T (V8Int32 -> LLVM.Value I.Int8 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +pslldi256_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.di.256" + +pslldi512_mask :: Ext.T (V16Int32 -> LLVM.Value I.Int8 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +pslldi512_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.di.512" + +psllq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +psllq128_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.q.128" + +psllq256_mask :: Ext.T (V4Int64 -> V2Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +psllq256_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.q.256" + +psllqi128_mask :: Ext.T (V2Int64 -> LLVM.Value I.Int8 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +psllqi128_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.qi.128" + +psllqi256_mask :: Ext.T (V4Int64 -> LLVM.Value I.Int8 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +psllqi256_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.qi.256" + +psllqi512_mask :: Ext.T (V8Int64 -> LLVM.Value I.Int8 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +psllqi512_mask = Ext.intrinsic ExtX86.avx512 "mask.psll.qi.512" + +psrav16hi_mask :: Ext.T (V16Int16 -> V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psrav16hi_mask = Ext.intrinsic ExtX86.avx512 "mask.psrav16.hi" + +psrav32hi_mask :: Ext.T (V32Int16 -> V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +psrav32hi_mask = Ext.intrinsic ExtX86.avx512 "mask.psrav32.hi" + +psrav4si_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +psrav4si_mask = Ext.intrinsic ExtX86.avx512 "mask.psrav4.si" + +psrav8hi_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +psrav8hi_mask = Ext.intrinsic ExtX86.avx512 "mask.psrav8.hi" + +psrav8si_mask :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +psrav8si_mask = Ext.intrinsic ExtX86.avx512 "mask.psrav8.si" + +psravq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +psravq128_mask = Ext.intrinsic ExtX86.avx512 "mask.psrav.q.128" + +psravq256_mask :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +psravq256_mask = Ext.intrinsic ExtX86.avx512 "mask.psrav.q.256" + +psrlv16hi_mask :: Ext.T (V16Int16 -> V16Int16 -> V16Int16 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int16)) +psrlv16hi_mask = Ext.intrinsic ExtX86.avx512 "mask.psrlv16.hi" + +psrlv2di_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +psrlv2di_mask = Ext.intrinsic ExtX86.avx512 "mask.psrlv2.di" + +psrlv32hi_mask :: Ext.T (V32Int16 -> V32Int16 -> V32Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V32Int16)) +psrlv32hi_mask = Ext.intrinsic ExtX86.avx512 "mask.psrlv32hi" + +psrlv4di_mask :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +psrlv4di_mask = Ext.intrinsic ExtX86.avx512 "mask.psrlv4.di" + +psrlv4si_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +psrlv4si_mask = Ext.intrinsic ExtX86.avx512 "mask.psrlv4.si" + +psrlv8hi_mask :: Ext.T (V8Int16 -> V8Int16 -> V8Int16 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int16)) +psrlv8hi_mask = Ext.intrinsic ExtX86.avx512 "mask.psrlv8.hi" + +psrlv8si_mask :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +psrlv8si_mask = Ext.intrinsic ExtX86.avx512 "mask.psrlv8.si" + +prorvd128_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +prorvd128_mask = Ext.intrinsic ExtX86.avx512 "mask.prorv.d.128" + +prorvd256_mask :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +prorvd256_mask = Ext.intrinsic ExtX86.avx512 "mask.prorv.d.256" + +prorvd512_mask :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +prorvd512_mask = Ext.intrinsic ExtX86.avx512 "mask.prorv.d.512" + +prorvq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +prorvq128_mask = Ext.intrinsic ExtX86.avx512 "mask.prorv.q.128" + +prorvq256_mask :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +prorvq256_mask = Ext.intrinsic ExtX86.avx512 "mask.prorv.q.256" + +prorvq512_mask :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +prorvq512_mask = Ext.intrinsic ExtX86.avx512 "mask.prorv.q.512" + +prold128_mask :: Ext.T (V4Int32 -> LLVM.Value I.Int8 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +prold128_mask = Ext.intrinsic ExtX86.avx512 "mask.prol.d.128" + +prold256_mask :: Ext.T (V8Int32 -> LLVM.Value I.Int8 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +prold256_mask = Ext.intrinsic ExtX86.avx512 "mask.prol.d.256" + +prold512_mask :: Ext.T (V16Int32 -> LLVM.Value I.Int8 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +prold512_mask = Ext.intrinsic ExtX86.avx512 "mask.prol.d.512" + +prolq128_mask :: Ext.T (V2Int64 -> LLVM.Value I.Int8 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +prolq128_mask = Ext.intrinsic ExtX86.avx512 "mask.prol.q.128" + +prolq256_mask :: Ext.T (V4Int64 -> LLVM.Value I.Int8 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +prolq256_mask = Ext.intrinsic ExtX86.avx512 "mask.prol.q.256" + +prolq512_mask :: Ext.T (V8Int64 -> LLVM.Value I.Int8 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +prolq512_mask = Ext.intrinsic ExtX86.avx512 "mask.prol.q.512" + +prolvd128_mask :: Ext.T (V4Int32 -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +prolvd128_mask = Ext.intrinsic ExtX86.avx512 "mask.prolv.d.128" + +prolvd256_mask :: Ext.T (V8Int32 -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +prolvd256_mask = Ext.intrinsic ExtX86.avx512 "mask.prolv.d.256" + +prolvd512_mask :: Ext.T (V16Int32 -> V16Int32 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +prolvd512_mask = Ext.intrinsic ExtX86.avx512 "mask.prolv.d.512" + +prolvq128_mask :: Ext.T (V2Int64 -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +prolvq128_mask = Ext.intrinsic ExtX86.avx512 "mask.prolv.q.128" + +prolvq256_mask :: Ext.T (V4Int64 -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +prolvq256_mask = Ext.intrinsic ExtX86.avx512 "mask.prolv.q.256" + +prolvq512_mask :: Ext.T (V8Int64 -> V8Int64 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +prolvq512_mask = Ext.intrinsic ExtX86.avx512 "mask.prolv.q.512" + +prord128_mask :: Ext.T (V4Int32 -> LLVM.Value I.Int8 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +prord128_mask = Ext.intrinsic ExtX86.avx512 "mask.pror.d.128" + +prord256_mask :: Ext.T (V8Int32 -> LLVM.Value I.Int8 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +prord256_mask = Ext.intrinsic ExtX86.avx512 "mask.pror.d.256" + +prord512_mask :: Ext.T (V16Int32 -> LLVM.Value I.Int8 -> V16Int32 -> LLVM.Value I.Int16 -> LLVM.CodeGenFunction r (V16Int32)) +prord512_mask = Ext.intrinsic ExtX86.avx512 "mask.pror.d.512" + +prorq128_mask :: Ext.T (V2Int64 -> LLVM.Value I.Int8 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +prorq128_mask = Ext.intrinsic ExtX86.avx512 "mask.pror.q.128" + +prorq256_mask :: Ext.T (V4Int64 -> LLVM.Value I.Int8 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +prorq256_mask = Ext.intrinsic ExtX86.avx512 "mask.pror.q.256" + +prorq512_mask :: Ext.T (V8Int64 -> LLVM.Value I.Int8 -> V8Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int64)) +prorq512_mask = Ext.intrinsic ExtX86.avx512 "mask.pror.q.512" + +gatherd_pd :: Ext.T (V2Double -> LLVM.Value (Ptr ()) -> V4Int32 -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +gatherd_pd = Ext.intrinsic ExtX86.avx2 "gather.d.pd" + +gatherd_pd256 :: Ext.T (V4Double -> LLVM.Value (Ptr ()) -> V4Int32 -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +gatherd_pd256 = Ext.intrinsic ExtX86.avx2 "gather.d.pd.256" + +gatherq_pd :: Ext.T (V2Double -> LLVM.Value (Ptr ()) -> V2Int64 -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +gatherq_pd = Ext.intrinsic ExtX86.avx2 "gather.q.pd" + +gatherq_pd256 :: Ext.T (V4Double -> LLVM.Value (Ptr ()) -> V4Int64 -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +gatherq_pd256 = Ext.intrinsic ExtX86.avx2 "gather.q.pd.256" + +gatherd_ps :: Ext.T (V4Float -> LLVM.Value (Ptr ()) -> V4Int32 -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +gatherd_ps = Ext.intrinsic ExtX86.avx2 "gather.d.ps" + +gatherd_ps256 :: Ext.T (V8Float -> LLVM.Value (Ptr ()) -> V8Int32 -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +gatherd_ps256 = Ext.intrinsic ExtX86.avx2 "gather.d.ps.256" + +gatherq_ps :: Ext.T (V4Float -> LLVM.Value (Ptr ()) -> V2Int64 -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +gatherq_ps = Ext.intrinsic ExtX86.avx2 "gather.q.ps" + +gatherq_ps256 :: Ext.T (V4Float -> LLVM.Value (Ptr ()) -> V4Int64 -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +gatherq_ps256 = Ext.intrinsic ExtX86.avx2 "gather.q.ps.256" + +gatherd_q :: Ext.T (V2Int64 -> LLVM.Value (Ptr ()) -> V4Int32 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +gatherd_q = Ext.intrinsic ExtX86.avx2 "gather.d.q" + +gatherd_q256 :: Ext.T (V4Int64 -> LLVM.Value (Ptr ()) -> V4Int32 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +gatherd_q256 = Ext.intrinsic ExtX86.avx2 "gather.d.q.256" + +gatherq_q :: Ext.T (V2Int64 -> LLVM.Value (Ptr ()) -> V2Int64 -> V2Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Int64)) +gatherq_q = Ext.intrinsic ExtX86.avx2 "gather.q.q" + +gatherq_q256 :: Ext.T (V4Int64 -> LLVM.Value (Ptr ()) -> V4Int64 -> V4Int64 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int64)) +gatherq_q256 = Ext.intrinsic ExtX86.avx2 "gather.q.q.256" + +gatherd_d :: Ext.T (V4Int32 -> LLVM.Value (Ptr ()) -> V4Int32 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +gatherd_d = Ext.intrinsic ExtX86.avx2 "gather.d.d" + +gatherd_d256 :: Ext.T (V8Int32 -> LLVM.Value (Ptr ()) -> V8Int32 -> V8Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Int32)) +gatherd_d256 = Ext.intrinsic ExtX86.avx2 "gather.d.d.256" + +gatherq_d :: Ext.T (V4Int32 -> LLVM.Value (Ptr ()) -> V2Int64 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +gatherq_d = Ext.intrinsic ExtX86.avx2 "gather.q.d" + +gatherq_d256 :: Ext.T (V4Int32 -> LLVM.Value (Ptr ()) -> V4Int64 -> V4Int32 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Int32)) +gatherq_d256 = Ext.intrinsic ExtX86.avx2 "gather.q.d.256" + +pmovmskb256 :: Ext.T (V32Int8 -> LLVM.CodeGenFunction r (LLVM.Value I.Int32)) +pmovmskb256 = Ext.intrinsic ExtX86.avx2 "pmovmskb" + +pshufb256 :: Ext.T (V32Int8 -> V32Int8 -> LLVM.CodeGenFunction r (V32Int8)) +pshufb256 = Ext.intrinsic ExtX86.avx2 "pshuf.b" + +mpsadbw256 :: Ext.T (V32Int8 -> V32Int8 -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V16Int16)) +mpsadbw256 = Ext.intrinsic ExtX86.avx2 "mpsadbw" + +movntdqa256 :: Ext.T (LLVM.Value (Ptr ()) -> LLVM.CodeGenFunction r (V4Int64)) +movntdqa256 = Ext.intrinsic ExtX86.avx2 "movntdqa" + +vfmaddss :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +vfmaddss = Ext.intrinsic ExtX86.fma "vfmadd.ss" + +vfmaddsd :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +vfmaddsd = Ext.intrinsic ExtX86.fma "vfmadd.sd" + +vfmaddps :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +vfmaddps = Ext.intrinsic ExtX86.fma "vfmadd.ps" + +vfmaddpd :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +vfmaddpd = Ext.intrinsic ExtX86.fma "vfmadd.pd" + +vfmaddps256 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +vfmaddps256 = Ext.intrinsic ExtX86.fma "vfmadd.ps.256" + +vfmaddpd256 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +vfmaddpd256 = Ext.intrinsic ExtX86.fma "vfmadd.pd.256" + +vfmsubss :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +vfmsubss = Ext.intrinsic ExtX86.fma "vfmsub.ss" + +vfmsubsd :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +vfmsubsd = Ext.intrinsic ExtX86.fma "vfmsub.sd" + +vfmsubps :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +vfmsubps = Ext.intrinsic ExtX86.fma "vfmsub.ps" + +vfmsubpd :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +vfmsubpd = Ext.intrinsic ExtX86.fma "vfmsub.pd" + +vfmsubps256 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +vfmsubps256 = Ext.intrinsic ExtX86.fma "vfmsub.ps.256" + +vfmsubpd256 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +vfmsubpd256 = Ext.intrinsic ExtX86.fma "vfmsub.pd.256" + +vfnmaddss :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +vfnmaddss = Ext.intrinsic ExtX86.fma "vfnmadd.ss" + +vfnmaddsd :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +vfnmaddsd = Ext.intrinsic ExtX86.fma "vfnmadd.sd" + +vfnmaddps :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +vfnmaddps = Ext.intrinsic ExtX86.fma "vfnmadd.ps" + +vfnmaddpd :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +vfnmaddpd = Ext.intrinsic ExtX86.fma "vfnmadd.pd" + +vfnmaddps256 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +vfnmaddps256 = Ext.intrinsic ExtX86.fma "vfnmadd.ps.256" + +vfnmaddpd256 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +vfnmaddpd256 = Ext.intrinsic ExtX86.fma "vfnmadd.pd.256" + +vfnmsubss :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +vfnmsubss = Ext.intrinsic ExtX86.fma "vfnmsub.ss" + +vfnmsubsd :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +vfnmsubsd = Ext.intrinsic ExtX86.fma "vfnmsub.sd" + +vfnmsubps :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +vfnmsubps = Ext.intrinsic ExtX86.fma "vfnmsub.ps" + +vfnmsubpd :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +vfnmsubpd = Ext.intrinsic ExtX86.fma "vfnmsub.pd" + +vfnmsubps256 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +vfnmsubps256 = Ext.intrinsic ExtX86.fma "vfnmsub.ps.256" + +vfnmsubpd256 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +vfnmsubpd256 = Ext.intrinsic ExtX86.fma "vfnmsub.pd.256" + +vfmaddsubps :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +vfmaddsubps = Ext.intrinsic ExtX86.fma "vfmaddsub.ps" + +vfmaddsubpd :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +vfmaddsubpd = Ext.intrinsic ExtX86.fma "vfmaddsub.pd" + +vfmaddsubps256 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +vfmaddsubps256 = Ext.intrinsic ExtX86.fma "vfmaddsub.ps.256" + +vfmaddsubpd256 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +vfmaddsubpd256 = Ext.intrinsic ExtX86.fma "vfmaddsub.pd.256" + +vfmsubaddps :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.CodeGenFunction r (V4Float)) +vfmsubaddps = Ext.intrinsic ExtX86.fma "vfmsubadd.ps" + +vfmsubaddpd :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.CodeGenFunction r (V2Double)) +vfmsubaddpd = Ext.intrinsic ExtX86.fma "vfmsubadd.pd" + +vfmsubaddps256 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.CodeGenFunction r (V8Float)) +vfmsubaddps256 = Ext.intrinsic ExtX86.fma "vfmsubadd.ps.256" + +vfmsubaddpd256 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.CodeGenFunction r (V4Double)) +vfmsubaddpd256 = Ext.intrinsic ExtX86.fma "vfmsubadd.pd.256" + +vfmaddpd128_mask :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vfmaddpd128_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmadd.pd.128" + +vfmaddpd128_mask3 :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vfmaddpd128_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmadd.pd.128" + +vfmaddpd128_maskz :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vfmaddpd128_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmadd.pd.128" + +vfmaddpd256_mask :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vfmaddpd256_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmadd.pd.256" + +vfmaddpd256_mask3 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vfmaddpd256_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmadd.pd.256" + +vfmaddpd256_maskz :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vfmaddpd256_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmadd.pd.256" + +vfmaddpd512_mask :: Ext.T (V8Double -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Double)) +vfmaddpd512_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmadd.pd.512" + +vfmaddpd512_mask3 :: Ext.T (V8Double -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Double)) +vfmaddpd512_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmadd.pd.512" + +vfmaddpd512_maskz :: Ext.T (V8Double -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Double)) +vfmaddpd512_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmadd.pd.512" + +vfmaddps128_mask :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vfmaddps128_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmadd.ps.128" + +vfmaddps128_mask3 :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vfmaddps128_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmadd.ps.128" + +vfmaddps128_maskz :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vfmaddps128_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmadd.ps.128" + +vfmaddps256_mask :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vfmaddps256_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmadd.ps.256" + +vfmaddps256_mask3 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vfmaddps256_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmadd.ps.256" + +vfmaddps256_maskz :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vfmaddps256_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmadd.ps.256" + +vfmaddps512_mask :: Ext.T (V16Float -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Float)) +vfmaddps512_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmadd.ps.512" + +vfmaddps512_mask3 :: Ext.T (V16Float -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Float)) +vfmaddps512_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmadd.ps.512" + +vfmaddps512_maskz :: Ext.T (V16Float -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Float)) +vfmaddps512_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmadd.ps.512" + +vfmaddsubpd128_mask :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vfmaddsubpd128_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmaddsub.pd.128" + +vfmaddsubpd128_mask3 :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vfmaddsubpd128_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmaddsub.pd.128" + +vfmaddsubpd128_maskz :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vfmaddsubpd128_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmaddsub.pd.128" + +vfmaddsubpd256_mask :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vfmaddsubpd256_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmaddsub.pd.256" + +vfmaddsubpd256_mask3 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vfmaddsubpd256_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmaddsub.pd.256" + +vfmaddsubpd256_maskz :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vfmaddsubpd256_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmaddsub.pd.256" + +vfmaddsubpd512_mask :: Ext.T (V8Double -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Double)) +vfmaddsubpd512_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmaddsub.pd.512" + +vfmaddsubpd512_mask3 :: Ext.T (V8Double -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Double)) +vfmaddsubpd512_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmaddsub.pd.512" + +vfmaddsubpd512_maskz :: Ext.T (V8Double -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Double)) +vfmaddsubpd512_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmaddsub.pd.512" + +vfmaddsubps128_mask :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vfmaddsubps128_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmaddsub.ps.128" + +vfmaddsubps128_mask3 :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vfmaddsubps128_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmaddsub.ps.128" + +vfmaddsubps128_maskz :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vfmaddsubps128_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmaddsub.ps.128" + +vfmaddsubps256_mask :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vfmaddsubps256_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmaddsub.ps.256" + +vfmaddsubps256_mask3 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vfmaddsubps256_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmaddsub.ps.256" + +vfmaddsubps256_maskz :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vfmaddsubps256_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmaddsub.ps.256" + +vfmaddsubps512_mask :: Ext.T (V16Float -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Float)) +vfmaddsubps512_mask = Ext.intrinsic ExtX86.avx512 "mask.vfmaddsub.ps.512" + +vfmaddsubps512_mask3 :: Ext.T (V16Float -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Float)) +vfmaddsubps512_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmaddsub.ps.512" + +vfmaddsubps512_maskz :: Ext.T (V16Float -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Float)) +vfmaddsubps512_maskz = Ext.intrinsic ExtX86.avx512 "maskz.vfmaddsub.ps.512" + +vfmsubpd128_mask3 :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vfmsubpd128_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsub.pd.128" + +vfmsubpd256_mask3 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vfmsubpd256_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsub.pd.256" + +vfmsubpd512_mask3 :: Ext.T (V8Double -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Double)) +vfmsubpd512_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsub.pd.512" + +vfmsubps128_mask3 :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vfmsubps128_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsub.ps.128" + +vfmsubps256_mask3 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vfmsubps256_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsub.ps.256" + +vfmsubps512_mask3 :: Ext.T (V16Float -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Float)) +vfmsubps512_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsub.ps.512" + +vfmsubaddpd128_mask3 :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vfmsubaddpd128_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsubadd.pd.128" + +vfmsubaddpd256_mask3 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vfmsubaddpd256_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsubadd.pd.256" + +vfmsubaddpd512_mask3 :: Ext.T (V8Double -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Double)) +vfmsubaddpd512_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsubadd.pd.512" + +vfmsubaddps128_mask3 :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vfmsubaddps128_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsubadd.ps.128" + +vfmsubaddps256_mask3 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vfmsubaddps256_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsubadd.ps.256" + +vfmsubaddps512_mask3 :: Ext.T (V16Float -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Float)) +vfmsubaddps512_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfmsubadd.ps.512" + +vfnmaddpd128_mask :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vfnmaddpd128_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmadd.pd.128" + +vfnmaddpd256_mask :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vfnmaddpd256_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmadd.pd.256" + +vfnmaddpd512_mask :: Ext.T (V8Double -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Double)) +vfnmaddpd512_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmadd.pd.512" + +vfnmaddps128_mask :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vfnmaddps128_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmadd.ps.128" + +vfnmaddps256_mask :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vfnmaddps256_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmadd.ps.256" + +vfnmaddps512_mask :: Ext.T (V16Float -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Float)) +vfnmaddps512_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmadd.ps.512" + +vfnmsubpd128_mask :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vfnmsubpd128_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmsub.pd.128" + +vfnmsubpd128_mask3 :: Ext.T (V2Double -> V2Double -> V2Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V2Double)) +vfnmsubpd128_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfnmsub.pd.128" + +vfnmsubpd256_mask :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vfnmsubpd256_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmsub.pd.256" + +vfnmsubpd256_mask3 :: Ext.T (V4Double -> V4Double -> V4Double -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Double)) +vfnmsubpd256_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfnmsub.pd.256" + +vfnmsubpd512_mask :: Ext.T (V8Double -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Double)) +vfnmsubpd512_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmsub.pd.512" + +vfnmsubpd512_mask3 :: Ext.T (V8Double -> V8Double -> V8Double -> LLVM.Value I.Int8 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V8Double)) +vfnmsubpd512_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfnmsub.pd.512" + +vfnmsubps128_mask :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vfnmsubps128_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmsub.ps.128" + +vfnmsubps128_mask3 :: Ext.T (V4Float -> V4Float -> V4Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V4Float)) +vfnmsubps128_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfnmsub.ps.128" + +vfnmsubps256_mask :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vfnmsubps256_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmsub.ps.256" + +vfnmsubps256_mask3 :: Ext.T (V8Float -> V8Float -> V8Float -> LLVM.Value I.Int8 -> LLVM.CodeGenFunction r (V8Float)) +vfnmsubps256_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfnmsub.ps.256" + +vfnmsubps512_mask :: Ext.T (V16Float -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Float)) +vfnmsubps512_mask = Ext.intrinsic ExtX86.avx512 "mask.vfnmsub.ps.512" + +vfnmsubps512_mask3 :: Ext.T (V16Float -> V16Float -> V16Float -> LLVM.Value I.Int16 -> LLVM.Value I.Int32 -> LLVM.CodeGenFunction r (V16Float)) +vfnmsubps512_mask3 = Ext.intrinsic ExtX86.avx512 "mask3.vfnmsub.ps.512" + + diff --git a/src/PrepareIntrinsics.hs b/src/PrepareIntrinsics.hs new file mode 100644 --- /dev/null +++ b/src/PrepareIntrinsics.hs @@ -0,0 +1,326 @@ +{-# LANGUAGE DeriveFunctor #-} +{-# LANGUAGE DeriveFoldable #-} +{-# LANGUAGE DeriveTraversable #-} +{- | +Parse an Intrinsics file and generate a Haskell interface to every intrinsic. +This is currently only tested and used for IntrinsicsX86.td +and relies on the flat structure of IntrinsicsX86.td. +In contrast to that, IntrinsicsPowerPC.td uses custom classes +and thus cannot be processed by this program. + +A safer way would be to invoke the llvm-tblgen utility in some way. + +1. We could write some Haskell or C++ code, + that queries the intrinsics from the include/llvm/Intrinsics.h interface. + +2. We could write a custom variant of llvm-tblgen + with a back-end that creates the Haskell interface for intrinsics. + This can be written in C++ or + we have to call the TableGen library functions from Haskell somehow. + +3. We could ask llvm-tblgen for a list of all records and parse its output. + This requires no C++ coding, + but we rely on the output format of @-print-records@. + + > llvm-tblgen -I /usr/local/llvm-3.1/include /usr/local/llvm-3.1/include/llvm/Intrinsics.td -print-records +-} +module Main where + +import qualified Text.ParserCombinators.Parsec.Token as T +import qualified Text.ParserCombinators.Parsec.Language as L +import qualified Text.ParserCombinators.Parsec as Parsec +import Text.ParserCombinators.Parsec (CharParser, (<|>), ) + +import qualified Control.Monad.Trans.Writer as MW +import qualified Data.Map as M +import qualified Data.Set as S + +import qualified Data.Traversable as Trav +import qualified Data.Foldable as Fold +import qualified Data.List.HT as ListHT +import qualified Data.List as List +import qualified Data.Char as Char +import Control.Monad (mzero, ) +import Control.Functor.HT (void, ) +import Data.Maybe (fromMaybe, ) + +import qualified System.IO as IO + + +data Intrinsic typ = Intrinsic Name Name (FunctionType typ) + deriving (Show, Functor, Fold.Foldable, Trav.Traversable) + +data FunctionType typ = FunctionType [typ] [typ] + deriving (Show, Functor, Fold.Foldable, Trav.Traversable) + +type Name = String + +data QualName = QualName String String String + +newtype LLVMType = LLVMType String + deriving (Show) + +newtype HaskellType = HaskellType {haskellTypeDecons :: String} + deriving (Show, Eq, Ord) + + +gccBuiltinPrefix :: String +gccBuiltinPrefix = "__builtin_ia32_" + +unsignedFunctions :: S.Set String +unsignedFunctions = S.fromList $ map (gccBuiltinPrefix++) $ + "packusdw128" : + "packusdw256" : + "packuswb128" : + "packuswb256" : + "paddusb128" : + "paddusb256" : + "paddusw128" : + "paddusw256" : + "phminposuw128" : + "pmaddubsw128" : + "pmaddubsw256" : + "pmaxub128" : + "pmaxub256" : + "pmaxud128" : + "pmaxud256" : + "pmaxuw128" : + "pmaxuw256" : + "pminub128" : + "pminub256" : + "pminud128" : + "pminud256" : + "pminuw128" : + "pminuw256" : + "pmulhuw128" : + "pmulhuw256" : + "pmuludq128" : + "pmuludq256" : + "psubusb128" : + "psubusb256" : + "psubusw128" : + "psubusw256" : + "vphaddubd" : + "vphaddubq" : + "vphaddubw" : + "vphaddudq" : + "vphadduwd" : + "vphadduwq" : + -- it's only the flag set that is unsigned + -- the floating point operands are always signed + "roundps" : + "roundpd" : + "roundps256" : + "roundpd256" : + "roundss" : + "roundsd" : + "cmpps" : + "cmppd" : + "cmpps256" : + "cmppd256" : + "cmpss" : + "cmpsd" : + [] + +translateType :: + Bool -> LLVMType -> + MW.Writer (M.Map HaskellType HaskellType) HaskellType +translateType signed (LLVMType llvmTypeStr) = + let formatQType (mqual, typ) = + maybe "" (++".") mqual ++ typ + returnType shortType longType = do + MW.tell (M.singleton shortType longType) + return shortType + composedType = do + vec <- Parsec.optionMaybe $ do + void $ Parsec.char 'v' + Parsec.many1 Parsec.digit + prim <- Parsec.choice $ + (do void $ Parsec.char 'i' + fmap + (\n -> + if signed + then (Just "I", "Int"++n) + else (Just "W", "Word"++n)) $ + Parsec.many1 Parsec.digit) : + (do void $ Parsec.char 'f' + n <- Parsec.many1 Parsec.digit + case n of + "32" -> return (Nothing, "Float") + "64" -> return (Nothing, "Double") + _ -> return $ (Just "LLVM", "FP" ++ n)) : + [] + return $ + case vec of + Nothing -> return $ HaskellType $ "LLVM.Value " ++ formatQType prim + Just d -> + returnType + (HaskellType $ "V" ++ d ++ snd prim) + (HaskellType $ + "LLVM.Value (LLVM.Vector TypeNum.D" ++ + d ++ " " ++ formatQType prim ++ ")") + p = do + void $ Parsec.string "llvm_" + haskType <- Parsec.choice $ + (Parsec.string "x86mmx" >> + return (returnType (HaskellType "MMX") (HaskellType "LLVM.Value (LLVM.Vector TypeNum.D8 W.Word8)"))) : + (Parsec.string "ptr" >> + return (return (HaskellType "LLVM.Value (Ptr ())"))) : + composedType : + [] + void $ Parsec.string "_ty" + return haskType + in case Parsec.parse p "" llvmTypeStr of + Left _msg -> + let typeSyn = HaskellType $ + case llvmTypeStr of + c:cs -> Char.toUpper c : cs + _ -> "" + in do + MW.tell (M.singleton typeSyn (HaskellType "LLVM.Value ()")) + return typeSyn + Right act -> act + +splitName :: Name -> QualName +splitName name = + let p = do + void $ Parsec.string "int_" + arch <- Parsec.many1 Parsec.alphaNum + void $ Parsec.char '_' + feature <- Parsec.many1 Parsec.alphaNum + void $ Parsec.char '_' + stem <- Parsec.many1 Parsec.anyChar + return $ QualName arch feature stem + in case Parsec.parse p "" name of + Left _msg -> QualName "" "" name + Right qname -> qname + +featureMap :: M.Map String String +featureMap = M.fromList $ + ("sse", "sse1") : + ("aesni", "aes") : + ("3dnow", "amd3dnow") : + ("3dnowa", "amd3dnowa") : + [] + +formatIntrinsicInHaskell :: Intrinsic HaskellType -> String +formatIntrinsicInHaskell + (Intrinsic name gccblt (FunctionType parameters results)) = + let (QualName _arch feature stem) = splitName name + dotStem = map (\c -> case c of '_' -> '.'; _ -> c) stem + haskName = + fromMaybe gccblt $ + ListHT.maybePrefixOf gccBuiltinPrefix gccblt + resultStr = + if null results + then "LLVM.Value ()" + else List.intercalate ", " $ map haskellTypeDecons results + in unlines $ + (haskName ++ " :: Ext.T (" ++ + concatMap (\(HaskellType typ) -> typ ++ " -> ") parameters ++ + "LLVM.CodeGenFunction r (" ++ resultStr ++ "))") : + (haskName ++ " = Ext.intrinsic ExtX86." ++ + M.findWithDefault feature feature featureMap ++ + " " ++ show dotStem) : + [] + +convertIntrinsics :: [Intrinsic LLVMType] -> String +convertIntrinsics intrinsics = + unlines $ + "{- Do not edit! This file was created with the PrepareIntrinsics tool. -}" : + "module LLVM.Extra.Extension.X86Auto where" : + "" : + "import qualified LLVM.Extra.Extension as Ext" : + "import qualified LLVM.Extra.ExtensionCheck.X86 as ExtX86" : + "import qualified LLVM.Core as LLVM" : + "import qualified Type.Data.Num.Decimal as TypeNum" : + "import qualified Data.Int as I" : + "import qualified Data.Word as W" : + "import Foreign.Ptr (Ptr, )" : + "" : + case MW.runWriter $ + mapM (\intr@(Intrinsic _ gccblt _) -> + Trav.traverse (translateType (not $ S.member gccblt unsignedFunctions)) intr) $ + filter (\(Intrinsic _ gccblt _) -> not $ null gccblt) intrinsics of + (funcs, types) -> + (map (\(HaskellType short, HaskellType long) -> + "type " ++ short ++ " = " ++ long) $ + M.toList types) ++ + "" : + (map formatIntrinsicInHaskell funcs) + +lexer :: T.TokenParser st +lexer = + T.makeTokenParser $ L.emptyDef { + L.commentStart = "/*", + L.commentEnd = "*/", + L.commentLine = "//", + L.nestedComments = False, + L.identStart = identifierStart, + L.identLetter = identifierLetter, + L.opStart = mzero, + L.opLetter = mzero, + L.caseSensitive = True, + L.reservedNames = [ "let", "def", "in" ], + L.reservedOpNames = [ "=", ":", "," ] + } + +identifierStart, identifierLetter :: CharParser st Char +identifierStart = Parsec.letter <|> Parsec.char '_' + +identifierLetter = + Parsec.alphaNum <|> Parsec.char '_' <|> Parsec.char '.' + + +gccBuiltin :: CharParser st String +gccBuiltin = do + T.reserved lexer "GCCBuiltin" + T.angles lexer $ T.stringLiteral lexer + +llvmType :: CharParser st LLVMType +llvmType = fmap LLVMType $ T.identifier lexer + +intrinsic :: CharParser st (FunctionType LLVMType) +intrinsic = + Parsec.between (T.reserved lexer "Intrinsic") (T.semi lexer) $ + T.angles lexer $ do + results <- T.brackets lexer $ T.commaSep lexer llvmType + void $ T.comma lexer + parameters <- T.brackets lexer $ T.commaSep lexer llvmType + Parsec.optional $ do + void $ T.comma lexer + _attributes <- T.brackets lexer $ T.commaSep lexer $ T.identifier lexer + return () + return $ FunctionType parameters results + +letBlock :: CharParser st [Intrinsic LLVMType] +letBlock = do + T.reserved lexer "let" + T.reserved lexer "TargetPrefix" + void $ T.symbol lexer "=" + _prefix <- T.stringLiteral lexer + T.reserved lexer "in" + T.braces lexer $ Parsec.many $ do + T.reserved lexer "def" + name <- T.identifier lexer + void $ T.colon lexer + gccblt <- Parsec.option "" $ do + gccblt <- gccBuiltin + void $ T.comma lexer + return gccblt + intr <- intrinsic + return $ Intrinsic name gccblt intr + +parser :: CharParser st [Intrinsic LLVMType] +parser = + fmap concat $ Parsec.many1 letBlock + +main :: IO () +main = do + parsed <- + Parsec.parseFromFile (T.whiteSpace lexer >> parser) + "/usr/local/llvm-3.8/include/llvm/IR/IntrinsicsX86.td" + case parsed of + Left msg -> IO.hPutStrLn IO.stderr $ show msg + Right intrinsics -> + writeFile "src/LLVM/Extra/Extension/X86Auto.hs" $ convertIntrinsics intrinsics diff --git a/x86/cpuid/LLVM/Extra/ExtensionCheck/X86.hs b/x86/cpuid/LLVM/Extra/ExtensionCheck/X86.hs new file mode 100644 --- /dev/null +++ b/x86/cpuid/LLVM/Extra/ExtensionCheck/X86.hs @@ -0,0 +1,71 @@ +module LLVM.Extra.ExtensionCheck.X86 ( + sse1, sse2, sse3, ssse3, sse41, sse42, avx, avx2, avx512, + fma, amd3dnow, amd3dnowa, aes, sse4a, + ) where + +import qualified LLVM.Extra.Extension as Ext +import qualified System.Cpuid as CPUID +import qualified System.Unsafe as Unsafe + +{- +I expect that the cpuid does not suddenly change +and thus calling Unsafe.performIO is safe. +-} +subtarget :: + String -> + (CPUID.FlagSet CPUID.Feature1C -> CPUID.FlagSet CPUID.Feature1D -> Bool) -> + Ext.Subtarget +subtarget name q = + Ext.Subtarget "x86" name + (return $ Unsafe.performIO $ check q) + +check :: + (CPUID.FlagSet CPUID.Feature1C -> CPUID.FlagSet CPUID.Feature1D -> Bool) -> + IO Bool +check q = + fmap (uncurry q) $ CPUID.features + + +-- * target specific extensions + +sse1 :: Ext.Subtarget +sse1 = subtarget "sse" (\_ecx edx -> CPUID.testFlag CPUID.sse edx) + +sse2 :: Ext.Subtarget +sse2 = subtarget "sse2" (\_ecx edx -> CPUID.testFlag CPUID.sse2 edx) + +sse3 :: Ext.Subtarget +sse3 = subtarget "sse3" (\ecx _edx -> CPUID.testFlag CPUID.sse3 ecx) + +ssse3 :: Ext.Subtarget +ssse3 = subtarget "ssse3" (\ecx _edx -> CPUID.testFlag CPUID.ssse3 ecx) + +sse41 :: Ext.Subtarget +sse41 = subtarget "sse41" (\ecx _edx -> CPUID.testFlag CPUID.sse4_1 ecx) + +sse42 :: Ext.Subtarget +sse42 = subtarget "sse42" (\ecx _edx -> CPUID.testFlag CPUID.sse4_2 ecx) + +avx :: Ext.Subtarget +avx = subtarget "avx" (\ecx _edx -> CPUID.testFlag CPUID.avx ecx) + +avx2 :: Ext.Subtarget +avx2 = subtarget "avx2" (\ _ecx _edx -> False) + +avx512 :: Ext.Subtarget +avx512 = subtarget "avx512" (\ _ecx _edx -> False) + +fma :: Ext.Subtarget +fma = subtarget "fma" (\ ecx _edx -> CPUID.testFlag CPUID.fma ecx) + +amd3dnow :: Ext.Subtarget +amd3dnow = subtarget "3dnow" (\ _ecx _edx -> False) + +amd3dnowa :: Ext.Subtarget +amd3dnowa = subtarget "3dnowa" (\ _ecx _edx -> False) + +aes :: Ext.Subtarget +aes = subtarget "aesni" (\ _ecx _edx -> False) + +sse4a :: Ext.Subtarget +sse4a = subtarget "sse4a" (\ _ecx _edx -> False) diff --git a/x86/none/LLVM/Extra/ExtensionCheck/X86.hs b/x86/none/LLVM/Extra/ExtensionCheck/X86.hs new file mode 100644 --- /dev/null +++ b/x86/none/LLVM/Extra/ExtensionCheck/X86.hs @@ -0,0 +1,55 @@ +module LLVM.Extra.ExtensionCheck.X86 ( + sse1, sse2, sse3, ssse3, sse41, sse42, avx, avx2, avx512, + fma, amd3dnow, amd3dnowa, aes, sse4a, + ) where + +import qualified LLVM.Extra.Extension as Ext + +subtarget :: String -> Bool -> Ext.Subtarget +subtarget name q = + Ext.Subtarget "x86" name (return q) + + +-- * target specific extensions + +sse1 :: Ext.Subtarget +sse1 = subtarget "sse" False + +sse2 :: Ext.Subtarget +sse2 = subtarget "sse2" False + +sse3 :: Ext.Subtarget +sse3 = subtarget "sse3" False + +ssse3 :: Ext.Subtarget +ssse3 = subtarget "ssse3" False + +sse41 :: Ext.Subtarget +sse41 = subtarget "sse41" False + +sse42 :: Ext.Subtarget +sse42 = subtarget "sse42" False + +avx :: Ext.Subtarget +avx = subtarget "avx" False + +avx2 :: Ext.Subtarget +avx2 = subtarget "avx2" False + +avx512 :: Ext.Subtarget +avx512 = subtarget "avx512" False + +fma :: Ext.Subtarget +fma = subtarget "fma" False + +amd3dnow :: Ext.Subtarget +amd3dnow = subtarget "3dnow" False + +amd3dnowa :: Ext.Subtarget +amd3dnowa = subtarget "3dnowa" False + +aes :: Ext.Subtarget +aes = subtarget "aesni" False + +sse4a :: Ext.Subtarget +sse4a = subtarget "sse4a" False