packages feed

llvm-extension (empty) → 0.0

raw patch · 10 files changed

+3845/−0 lines, 10 filesdep +basedep +containersdep +cpuidsetup-changed

Dependencies added: base, containers, cpuid, llvm-extra, llvm-tf, non-empty, parsec, prelude-compat, tfp, transformers, unsafe, utility-ht

Files

+ LICENSE view
@@ -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.
+ Makefile view
@@ -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
+ Setup.lhs view
@@ -0,0 +1,3 @@+#! /usr/bin/env runhaskell+> import Distribution.Simple+> main = defaultMain
+ llvm-extension.cabal view
@@ -0,0 +1,101 @@+Cabal-Version:  2.2+Name:           llvm-extension+Version:        0.0+License:        BSD-3-Clause+License-File:   LICENSE+Author:         Henning Thielemann <haskell@henning-thielemann.de>+Maintainer:     Henning Thielemann <haskell@henning-thielemann.de>+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
+ src/LLVM/Extra/Extension.hs view
@@ -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
+ src/LLVM/Extra/Extension/X86.hs view
@@ -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
+ src/LLVM/Extra/Extension/X86Auto.hs view
@@ -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"++
+ src/PrepareIntrinsics.hs view
@@ -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
+ x86/cpuid/LLVM/Extra/ExtensionCheck/X86.hs view
@@ -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)
+ x86/none/LLVM/Extra/ExtensionCheck/X86.hs view
@@ -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