7NT      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ ` a b c d e f g h i j k l m n opqrstuvwxyz{|}~       !"#$%&'() * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSNone Analogous to T 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. /This is an Applicative functor that registers, Gwhat extensions are needed in order to run the contained instructions. +You can escape from the functor by calling  (and providing a generic implementation. We use an applicative functor since with a monadic interface 5we 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 9where class constraints show what extensions are needed. KThis would be just like exceptions that are explicit in the type signature +as in the control-monad-exception package. RHowever we would still need to lift all basic LLVM instructions to the new monad. .Declare that a certain plain LLVM instruction #depends on a particular extension. 2This can be useful if you rely on the data layout 0of 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. 7Create 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. run generic specific generates the specific code ?if the required extensions are available on the host processor and generic otherwise. Convenient variant of : -Only run the code with extended instructions )if an additional condition is satisfied. Only for debugging purposes. U V WXY Z[   U V  WXY Z[None\] !" !" !"\] !"None^_`abcdefghijklmnopqrstuvwxyz{|}~#$%&'()*    +,  !"#$%&'()*+,-./01234-5.6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW/0XYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~^_`abcdefghijklmnopqrstuvwxyz{|}~#$%&'()*    +,  !"#$%&'()*+,-./01234-5.6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW/0XYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~^_`abcdefghijklmnopqrstuvwxyz{|}~#$%&'()*    +,  !"#$%&'()*+,-./01234-5.6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW/0XYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None Safe-Infered123123123123None"This would also work for vectors, /but LLVM-3.1 crashes when actually doing this. 456745674567NoneAn alternative to < 'where I try to persuade LLVM to use x86's LOOP instruction. %Unfortunately it becomes even worse. 5LLVM developers say that x86 LOOP is actually slower 9than manual decrement, zero test and conditional branch. AThis is a variant of ? that may be more convient, ,because you only need one lambda expression 'for both loop condition and loop body. B"This construct starts new blocks, )so be prepared when continueing after an B. EBranch-free variant of C 5that is faster if the enclosed block is very simply, .say, if it contains at most two instructions. &It can only be used as alternative to C /if the enclosed block is free of side effects. 89:;<=>?@ABCDE89:;<=>?@ABCDE:;<=>?A@BC89DE89:;<=>?@ABCDENoneFIf isJust = False, then fromJust is an  undefTuple. Jcounterpart to  Lcounterpart to  with swapped arguments N%counterpart to Data.Maybe.HT.toMaybe FGHIJKLMNOPQRSTUFGHIJKLMNOPQRSTUFGHIJKLMNOPQRSTUNoneVIf isRight, then fromLeft is an  undefTuple. If  not isRight, then  fromRight is an  undefTuple. I would prefer a union type, Jbut it was temporarily removed in LLVM-2.8 and did not return since then. [counterpart to  VWXYZ[\]^ VWXYZ[\]^VWXYZ[\]^ None,_`abcdefghij      _`abcdefghij debcf_`aghij(_`abcdefghij      Nonel*construct an array out of single elements DYou must assert that the length of the list matches the array size. &This can be considered the inverse of m. mKprovide the elements of an array as a list of individual virtual registers &This can be considered the inverse of l. nThe loop is unrolled, since  and  expect constant indices. klmnklmnklmnklmnNoneopFGHIJKLMNOPQRSTUopFGHIJKLMNOQPoSTRUpopNoneqr VWXYZ[\]^qr VWXYZ[^\]qrqrNoneWthe upper two integers are set to zero, there is no instruction that converts to Int64 Uthe upper two integers are ignored, there is no instruction that converts from Int64 +MXCSR is not really supported by LLVM-2.6. ILLVM does not know about the dependency of all floating point operations on this status register. cumulative sum: "(a,b,c,d) -> (a,a+b,a+b+c,a+b+c+d) &I try to cleverly use horizontal add, 8but the generic version in the Vector module is better. 2stuvwxyz{|}~;#$%&'()*+,-./0stuvwxyz{|}~;%#&$)'*(stuvwxyz{|}~+,0/-.2stuvwxyz{|}~ None Attention: .The rounding and fraction functions only work 4for floating point values with maximum magnitude of maxBound :: Int32. >This way we save expensive handling of possibly seldom cases. 8The order of addition is chosen for maximum efficiency. 'We do not try to prevent cancelations. CThe first result value is the sum of all vector elements from 0 to  div n 2 + 1 B and the second result value is the sum of vector elements from div n 2 to n-1.  n must be at least D2. JTreat the vector as concatenation of pairs and all these pairs are added. ( Useful for stereo signal processing.  n must be at least D2. GAllow to work on records of vectors as if they are vectors of records. EThis is a reasonable approach for records of different element types Jsince processor vectors can only be built from elements of the same type. ;But also, say, for chunked stereo signal this makes sense. In this case we would work on Stereo (Value a). -Formerly we used a two-way dependency Vector  - (Element, Size). ;Now we have only the dependency Vector -> (Element, Size). 3This means that we need some more type annotations as in umul32to64/ assemble, 5on the other hand we can allow multiple vector types 'with respect to the same element type. 5E.g. we can provide a vector type with pair elements 7where the pair elements are interleaved in the vector. ,Manually assemble a vector of equal values. %Better use ScalarOrVector.replicate. *construct a vector out of single elements EYou must assert that the length of the list matches the vector size. &This can be considered the inverse of . LManually implement vector shuffling using insertelement and extractelement. In contrast to LLVM':s built-in instruction it supports distinct vector sizes, $but it allows only one input vector =(or a tuple of vectors, but we cannot shuffle between them). (For more complex shuffling we recommend  and . 0Rotate one element towards the higher elements. I don'-t want to call it rotateLeft or rotateRight, =because there is no prefered layout for the vector elements. In Intel's instruction manual vector $elements are indexed like the bits, that is from right to left. @However, when working with Haskell list and enumeration syntax, the start index is left. Implement the ! method using the methods of the  class. Kprovide the elements of a vector as a list of individual virtual registers &This can be considered the inverse of . 8Like LLVM.Util.Loop.mapVector but the loop is unrolled, >which is faster since it can be packed by the code generator. 8Like LLVM.Util.Loop.mapVector but the loop is unrolled, >which is faster since it can be packed by the code generator. 7Ideally on ix86 with SSE41 this would be translated to dpps. +If the target vector type is a native type Fthen the chop operation produces no actual machine instruction. (nop) 3If the vector cannot be evenly divided into chunks 5the last chunk will be padded with undefined values. +The target size is determined by the type. EIf the chunk list provides more data, the exceeding data is dropped. )If the chunk list provides too few data, 5the target vector is filled with undefined elements. 6We partition a vector of size n into chunks of size m -and add these chunks using vector additions. .We do this by repeated halving of the vector, Hsince this way we do not need assumptions about the native vector size. *We reduce the vector size only virtually, Dthat is we maintain the vector size and fill with undefined values. This is reasonable Wsince LLVM-2.5 and LLVM-2.6 does not allow shuffling between vectors of different size ;and because it likes to do computations on Vector D2 Float in MMX registers on ix86 CPU's, &which interacts badly with FPU usage. 0Since we fill the vector with undefined values, ?LLVM actually treats the vectors like vectors of smaller size. Needs (log n) vector additions  .On LLVM-2.6 and X86 this produces branch-free but even slower code than fractionSelect, %since the comparison to booleans and 8back to a floating point number is translated literally 8to elementwise comparison, conversion to a 0 or -1 byte %and then to a floating point number. MLLVM.select on boolean vectors cannot be translated to X86 code in LLVM-2.6, >thus I code my own version that calls select on all elements. This is slow but works. IWhen this issue is fixed, this function will be replaced by LLVM.select. ! implemented using . This will need jumps. " implemented using . This will need jumps. #Another implementation of , 1this time in terms of binary logical operations. The selecting integers must be 5(-1) for selecting an element from the first operand 8and 0 for selecting an element from the second operand. This leads to optimal code. 7On SSE41 this could be done with blendvps or blendvpd. $%&'()*+,-./0123456789:;< =>?@A!"#BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs99{$%&'()*+,-./0123456789:;< =>?@A!"#BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs Nonean alternative is using the  vector type 0The fraction has the same sign as the argument. @This is not particular useful but fast on IEEE implementations. +increment (first operand) may be negative, "phase must always be non-negative .both increment and phase must be non-negative Rounds to the next integer. For numbers of the form n+0.5, *we choose one of the neighboured integers 8such that the overall implementation is most efficient. t=There are functions that are intended for processing scalars +but have formally vector input and output. ?This function breaks vector function down to a scalar function (by accessing the lowest vector element. _uvwxyzt{|}~Ruvwxyzt{|}~None$This and the following type classes Fare intended for arithmetic operations on wrappers around LLVM types. 5E.g. you might define a fixed point fraction type by   newtype Fixed = Fixed Int32 Mand then use the same methods for floating point and fixed point arithmetic. -In contrast to the arithmetic methods in the llvm wrapper, 7in our methods the types of operands and result match. FAdvantage: Type inference determines most of the types automatically. 7Disadvantage: You cannot use constant values directly, $but you have to convert them all to . $In Haskell terms this is a . (.both increment and phase must be non-negative P      !"#$%&'(=4567      !"#$%&'(= !"45#$%     &'(673      !"#$%&'( None4 It must hold 4 max x y == do gt <- cmp CmpGT x y; select gt x y ^ A nested . @ Since it is not obvious how deep to decompose nested tuples, 7 you must provide a pattern of the decomposed tuple.  E.g. " f :: MultiValue ((a,b),(c,d)) -> 7 ((MultiValue a, MultiValue b), MultiValue (c,d)) " f = decompose ((atom,atom),atom) a A nested . A combination of a and ^ =that let you operate on tuple multivalues as Haskell tuples. )*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[o)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~oijbcdefghklmnopqrstuvwxyz{|}~_`a]^\[YZWXUVQRSTOPMNLJKEFGHIBCDA@>?789:;<=563412,-./0)*+)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[None0Rotate one element towards the higher elements. I don'-t want to call it rotateLeft or rotateRight, =because there is no prefered layout for the vector elements. In Intel's instruction manual vector $elements are indexed like the bits, that is from right to left. @However, when working with Haskell list and enumeration syntax, the start index is left. \]^_`abcdefghijklmnopqrstuvwxyz{|}~LLe\]^_`abcdefghijklmnopqrstuvwxyz{|}~None None NoneAThe entire purpose of this datatype is to mark a type as scalar, 1although it might also be interpreted as vector. 6This way you can write generic operations for vectors  using the  class, 8and specialise them to scalar types with respect to the  class. From another perspective you can consider the  type constructor a marker  where the  type function 4stops reducing nested vector types to scalar types.   NoneAn implementation of both _ and  must ensure that  haskellValue is compatible with Stored (Struct haskellValue) (which we want to call  llvmStruct). That is, writing and reading  llvmStruct by LLVM must be the same as accessing  haskellValue by Storable methods. <ToDo: In future we may also require Storable constraint for  llvmStruct. KWe use a functional dependency in order to let type inference work nicely. D               5     NoneIsomorphic to =ReaderT (CodeGenFunction r z) (ContT z (CodeGenFunction r)) a, (where the reader provides the block for  &and the continuation part manages the . %counterpart to Data.Maybe.HT.toMaybe %4Run an exception handler if the Maybe-action fails. The exception is propagated. :That is, the handler is intended for a cleanup procedure. &>Run the first action and if that fails run the second action. ;If both actions fail, then the composed action fails, too. (9If the returned position is smaller than the array size, then returned final state is o.  !"#$%&'() !"#$%&'() !"#$%&'() !"#$%&'()None,*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS**+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS*6783459:012-./*+,;<=>?@ABCDEFGHILKJMNOPRQS"*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS !" !# !$ !% !& !' !()*++,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh/iYjklmnopqrfstu/vwx y z { | } ~  `          Y                !            X Y          " #                $ $ % & ' ( ) * +  , - .  / 0  f 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T r U V     ./0WWfXYHIKL2Z[\]^R_`a(+_`a(+bcdefghijfkTrlmnopqrs_`a(+tuvwxyz{|}f~klgj^Z[.    f      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                       ! " # $ % & ' ( ) * + , - . / 0 1 2 !3 !456789 : ; < = > ? @ A B  C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                    _                                    b c d e f g h i  j k                 W                                                      f g h i b c d e j k               ! " # $ % & ' ( ) * + , - . / 0              , 1 2 3 4 5 6 7 8 9 : ; <   = > ? @ A B C D E F G H I J KL345CDEMSTrjk"#$-./0IJK1,NOP<=>?@ABCDEFGHIJ$/0,1QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx= y z{|}_`~llvm-extra-0.7.1LLVM.Extra.ArithmeticLLVM.Extra.ExtensionLLVM.Extra.ExtensionCheck.X86LLVM.Extra.Extension.X86LLVM.Extra.MonadLLVM.Extra.ControlLLVM.Extra.MaybeLLVM.Extra.EitherLLVM.Extra.ClassLLVM.Extra.ArrayLLVM.Extra.VectorLLVM.Extra.ScalarOrVectorLLVM.Extra.Multi.ValueLLVM.Extra.Multi.VectorLLVM.Extra.Multi.Vector.MemoryLLVM.Extra.Multi.Value.MemoryLLVM.Extra.ScalarLLVM.Extra.MemoryLLVM.Extra.MaybeContinuationLLVM.Extra.Multi.ClassLLVM.Extra.Extension.X86AutoLLVM.Extra.MemoryPrivateLLVM.Extra.ArithmeticPrivateLLVM.Extra.MaybePrivate Data.Maybe fromMaybeLLVM.Extra.EitherPrivateScalarTMemoryCllvm-tf-3.1.0.1LLVM.Core.InstructionsCmpEQCmpNECmpGTCmpGECmpLTCmpLE CmpPredicateCallArgsResult Subtargetwrap intrinsic intrinsicAttrrunrunWhen runUnsafewithwith2with3sse1sse2sse3ssse3sse41sse42avxavx2avx512fmaamd3dnow amd3dnowaaessse4aminssminpsmaxssmaxpsminsdminpdmaxsdmaxpdhaddpshaddpdroundpsroundpddppddppschainliftR2liftR3incdecadvanceArrayElementPtrdecreaseArrayElementPtrSelectselect arrayLoop arrayLoop2arrayLoopWithExitarrayLoop2WithExitfixedLengthLoop whileLoop loopWithExitwhileLoopShared ifThenElseifThenselectTraversable ifThenSelectConsisJustfromJustfor alternativefromBooltoBooljust getIsNothinglift2sequencetraverseliftM2isRightfromLeft fromRightmapLeftmapRight getIsLeftMakeValueTuple ValueTuple valueTupleOfZero zeroTuple Undefined undefTuplezeroTuplePointedundefTuplePointedvalueTupleOfFunctorphisTraversableaddPhisFoldablesizeassemble extractAllmapnothingleftrightcmpsscmppscmpsdcmppdcmpps256cmppd256pcmpgtbpcmpgtwpcmpgtdpcmpgtqpcmpugtbpcmpugtwpcmpugtdpcmpugtqpminsbpmaxsbpminswpmaxswpminsdpmaxsdpminubpmaxubpminuwpmaxuwpminudpmaxudpabsbpabswpabsdpmuludqpmuldqpmulldcvtps2dqcvtpd2dqcvtdq2pscvtdq2pdldmxcsrstmxcsr withMXCSRroundssroundsdabsssabssdabspsabspdRealminmaxabssignumtruncatefractionfloor Arithmeticsum sumToPairsumInterleavedToPaircumulate dotProductmul Canonical ConstructConstantSimpleElementSize shuffleMatchextractinsertconstant replicate insertChunkiterateshuffle sizeInTuplerotateUp rotateDownreverseshiftUp shiftDownshiftUpMultiZeroshiftDownMultiZeroshuffleMatchTraversableshuffleMatchAccessshuffleMatchPlain1shuffleMatchPlain2insertTraversableextractTraversablemodify mapChunks zipChunksWithchopconcat cumulate1signedFraction umul32to64TranscendentalConstantconstPiRationalConstantconstFromRationalIntegerConstantconstFromInteger PseudoModulescale scaleConst ReplicatereplicateConstFraction addToPhaseincPhase truncateToIntroundToIntFast floorToIntsplitFractionToInt ceilingToInt replicateOfTranscendentalpisinlogexpcospow AlgebraicsqrtLogicandorxorinvFloatingComparisonfcmp Comparison CmpResultcmp fromRational'Fieldfdiv fromInteger' PseudoRingAdditivezeroaddsubnegonesquareidiviremIntegralNativeFloating NativeIntegerAtom PatternTuple Decomposed Decompose decomposeComposeComposedcomposeReprconsundefphisaddPhis consPrimitiveundefPrimitive zeroPrimitive phisPrimitiveaddPhisPrimitiveconsUnit undefUnitzeroUnitphisUnit addPhisUnitfstsndcurryuncurrymapFstmapSndswapfst3snd3thd3mapFst3mapSnd3mapThd3zipzip3zip4unzipunzip3unzip4modify2modifyFmodifyF2atomlift1liftM0liftMliftM3 fromIntegralValueconsPrim deconsPrimshuffleMatchPrimitiveextractPrimitiveinsertPrimitivedissect dissectListStructloadstore loadPrimitivestorePrimitivedecomposePrimitivecomposePrimitiveloadUnit storeUnit decomposeUnit composeUnit castStructPtrdeconsunliftMunliftM2unliftM3unliftM4unliftM5 FirstClassStoredRecordelement loadRecord storeRecorddecomposeRecord composeRecordcastStorablePtr loadNewtype storeNewtypedecomposeNewtypecomposeNewtyperesolvewithBooltoMaybeliftguardbindonFailOp2runOp2Op1runOp1Op0runOp0ConstgetConstswitchLLVM.Core.CodeGen FunctionArgsbuildIntrinsic targetNamenamecheck$fCallArgsCodeGenFunction$fCallArgs(->) subtargetV8Word32V8Word16V8Int64V8Int32V8Int16V8FloatV8DoubleV64Int8V4Word64V4Word32V4Int64V4Int32V4FloatV4DoubleV32Word8V32Int8V32Int16V2Word64V2Int64V2DoubleV16Word8 V16Word16V16Int8V16Int32V16Int16V16FloatMMXpavgusbpf2idpfaccpfaddpfcmpeqpfcmpgepfcmpgtpfmaxpfminpfmulpfrcppfrcpit1pfrcpit2pfrsqrtpfrsqit1pfsubpfsubrpi2fdpmulhrwpf2iwpfnaccpfpnaccpi2fwaddsssubssmulssdivsssqrtsssqrtpsrcpssrcppsrsqrtssrsqrtpscomieqcomiltcomilecomigtcomigecominequcomiequcomiltucomileucomigtucomigeucomineqcvtss2si cvtss2si64 cvttss2si cvttss2si64cvtsi2ss cvtsi642sscvtps2pi cvttps2picvtpi2psstoreupssfencemovmskpsaddsdsubsdmulsddivsdsqrtsdsqrtpdcomisdeqcomisdltcomisdlecomisdgtcomisdge comisdneq ucomisdeq ucomisdlt ucomisdle ucomisdgt ucomisdge ucomisdneq paddsb128 paddsw128 paddusb128 paddusw128 psubsb128 psubsw128 psubusb128 psubusw128 pmulhuw128 pmulhw128 pmuludq128 pmaddwd128pavgb128pavgw128 pmaxub128 pmaxsw128 pminub128 pminsw128 psadbw128psllw128pslld128psllq128psrlw128psrld128psrlq128psraw128psrad128 psllwi128 pslldi128 psllqi128 psrlwi128 psrldi128 psrlqi128 psrawi128 psradi128 cvttpd2dqcvtpd2ps cvttps2dqcvtps2pdcvtsd2si cvtsd2si64 cvttsd2si cvttsd2si64cvtsi2sd cvtsi642sdcvtsd2sscvtss2sdcvtpd2pi cvttpd2picvtpi2pdstoreupdstoredqu storelv4si packsswb128 packssdw128 packuswb128movmskpd pmovmskb128 maskmovdquclflushlfencemfencepauseaddsubpsaddsubpdhsubpshsubpdlddqumonitormwaitphaddw phaddw128phaddd phaddd128phaddsw phaddsw128phsubw phsubw128phsubd phsubd128phsubsw phsubsw128 pmaddubsw pmaddubsw128pmulhrsw pmulhrsw128pshufb pshufb128pshufdpshuflwpshufhwpshufwpsignb psignb128psignw psignw128psignd psignd128pabsb128pabsw128pabsd128 pmovsxbd128 pmovsxbq128 pmovsxbw128 pmovsxdq128 pmovsxwd128 pmovsxwq128 pmovzxbd128 pmovzxbq128 pmovzxbw128 pmovzxdq128 pmovzxwd128 pmovzxwq128 phminposuw128 pmaxsb128 pmaxsd128 pmaxud128 pmaxuw128 pminsb128 pminsd128 pminud128 pminuw128 aesimc128 aesenc128 aesenclast128 aesdec128 aesdeclast128aeskeygenassist128 packusdw128 pmuldq128 extractps128 insertps128 pblendvb128blendvpdblendvps mpsadbw128movntdqa ptestz128 ptestc128 ptestnzc128crc32qicrc32hicrc32sicrc32di pcmpistrm128 pcmpistri128 pcmpistria128 pcmpistric128 pcmpistrio128 pcmpistris128 pcmpistriz128 pcmpestrm128 pcmpestri128 pcmpestria128 pcmpestric128 pcmpestrio128 pcmpestris128 pcmpestriz128extrqiextrqinsertqiinsertqmovntssmovntsd addsubpd256 addsubps256maxpd256maxps256minpd256minps256 sqrtpd256 sqrtps256 rsqrtps256rcpps256 roundpd256 roundps256 haddpd256 hsubps256 hsubpd256 haddps256 vpermilvarpd vpermilvarpsvpermilvarpd256vpermilvarps256vperm2f128_pd256vperm2f128_ps256vperm2f128_si256vpermi2vard128_maskvpermi2vard256_maskvpermi2vard512_maskvpermi2varhi128_maskvpermi2varhi256_maskvpermi2varhi512_maskvpermi2varpd128_maskvpermi2varpd256_maskvpermi2varpd512_maskvpermi2varps128_maskvpermi2varps256_maskvpermi2varps512_maskvpermi2varq128_maskvpermi2varq256_maskvpermi2varq512_maskvpermt2vard512_maskvpermt2varq512_maskvpermt2varps512_maskvpermt2varpd512_maskvpermt2vard128_maskvpermt2vard128_maskzvpermt2vard256_maskvpermt2vard256_maskzvpermt2vard512_maskzvpermt2varhi128_maskvpermt2varhi128_maskzvpermt2varhi256_maskvpermt2varhi256_maskzvpermt2varhi512_maskvpermt2varhi512_maskzvpermt2varpd128_maskvpermt2varpd128_maskzvpermt2varpd256_maskvpermt2varpd256_maskzvpermt2varpd512_maskzvpermt2varps128_maskvpermt2varps128_maskzvpermt2varps256_maskvpermt2varps256_maskzvpermt2varps512_maskzvpermt2varq128_maskvpermt2varq128_maskzvpermt2varq256_maskvpermt2varq256_maskzvpermt2varq512_maskzvpermilpd_maskvpermilpd256_maskvpermilpd512_maskvpermilps_maskvpermilps256_maskvpermilps512_maskvpermilvarpd256_maskvpermilvarpd512_maskvpermilvarpd_maskvpermilvarps256_maskvpermilvarps512_maskvpermilvarps_maskpshufb128_maskpshufb256_maskpshufb512_maskpshufd128_maskpshufd256_maskpshufd512_maskpshufhw128_maskpshufhw256_maskpshufhw512_maskpshuflw128_maskpshuflw256_maskpshuflw512_maskshuf_f32x4_256_maskshuf_f32x4_maskshuf_f64x2_256_maskshuf_f64x2_maskshuf_i32x4_256_maskshuf_i32x4_maskshuf_i64x2_256_maskshuf_i64x2_maskshufpd128_maskshufpd256_maskshufpd512_maskshufps128_maskshufps256_maskshufps512_maskmovshdup128_maskmovshdup256_maskmovshdup512_maskmovsldup128_maskmovsldup256_maskmovsldup512_maskmovddup128_maskmovddup256_maskmovddup512_mask blendvpd256 blendvps256dpps256 cvtdq2pd256 cvtdq2ps256 cvtpd2ps256 cvtps2dq256 cvtps2pd256 cvttpd2dq256 cvtpd2dq256 cvttps2dq256vtestzpdvtestcpd vtestnzcpdvtestzpsvtestcps vtestnzcps vtestzpd256 vtestcpd256 vtestnzcpd256 vtestzps256 vtestcps256 vtestnzcps256 ptestz256 ptestc256 ptestnzc256 ptestmd512 ptestmq512fpclasspd128_maskfpclasspd256_maskfpclasspd512_maskfpclassps128_maskfpclassps256_maskfpclassps512_mask fpclasssd fpclassss movmskpd256 movmskps256vzeroall vzerouppervbroadcastf128_pd256vbroadcastf128_ps256lddqu256 storeupd256 storeups256 storedqu256 maskloadpd maskloadps maskloadpd256 maskloadps256loadups128_maskloadups256_maskloadups512_maskloadupd128_maskloadupd256_maskloadupd512_maskloadaps128_maskloadaps256_maskloadaps512_maskloadapd128_maskloadapd256_maskloadapd512_mask movss_mask movsd_mask maskstorepd maskstorepsmaskstorepd256maskstoreps256storeups512_maskstoreupd512_maskstoreaps512_maskstoreapd512_mask storess_mask paddsb256 paddsw256 paddusb256 paddusw256 psubsb256 psubsw256 psubusb256 psubusw256 pmulhuw256 pmulhw256 pmuludq256 pmuldq256 pmaddwd256pavgb256pavgw256 psadbw256 pmaxub256 pmaxuw256 pmaxud256 pmaxsb256 pmaxsw256 pmaxsd256 pminub256 pminuw256 pminud256 pminsb256 pminsw256 pminsd256pmaxsb128_maskpmaxsb256_maskpmaxsb512_maskpmaxub128_maskpmaxub256_maskpmaxub512_maskpmaxsw128_maskpmaxsw256_maskpmaxsw512_maskpmaxuw128_maskpmaxuw256_maskpmaxuw512_maskpminsb128_maskpminsb256_maskpminsb512_maskpminub128_maskpminub256_maskpminub512_maskpminsw128_maskpminsw256_maskpminsw512_maskpminuw128_maskpminuw256_maskpminuw512_maskpmaxud512_maskpmaxud256_maskpmaxud128_maskpmaxsd512_maskpmaxsd256_maskpmaxsd128_maskpmaxuq512_maskpmaxuq256_maskpmaxuq128_maskpmaxsq512_maskpmaxsq256_maskpmaxsq128_maskpminud512_maskpminud256_maskpminud128_maskpminsd512_maskpminsd256_maskpminsd128_maskpminuq512_maskpminuq256_maskpminuq128_maskpminsq512_maskpminsq256_maskpminsq128_maskpsllw256pslld256psllq256psrlw256psrld256psrlq256psraw256psrad256 psllwi256 pslldi256 psllqi256 psrlwi256 psrldi256 psrlqi256 psrawi256 psradi256 pslldi512 psllqi512 psrldi512 psrlqi512 psradi512 psraqi512 psrlw128_mask psrlw256_mask psrlw512_maskpsrlwi128_maskpsrlwi256_maskpsrlwi512_mask psraw128_mask psraw256_mask psraw512_maskpsrawi128_maskpsrawi256_maskpsrawi512_mask pslld512_mask psllq512_mask psrld512_mask psrlq512_mask psrad512_mask psraq512_mask psllw128_mask psllw256_mask psllw512_maskpsllwi128_maskpsllwi256_maskpsllwi512_maskpsllv16hi_mask psllv2di_maskpsllv32hi_mask psllv4di_mask psllv4si_mask psllv8hi_mask psllv8si_mask psrad128_mask psrad256_maskpsradi128_maskpsradi256_maskpsradi512_mask psraq128_mask psraq256_maskpsraqi128_maskpsraqi256_maskpsraqi512_mask psrld128_mask psrld256_maskpsrldi128_maskpsrldi256_maskpsrldi512_mask psrlq128_mask psrlq256_maskpsrlqi128_maskpsrlqi256_maskpsrlqi512_mask packsswb256 packssdw256 packuswb256 packusdw256pabsb256pabsw256pabsd256 pabsb128_mask pabsb256_mask pabsb512_mask pabsd128_mask pabsd256_mask pabsd512_mask pabsq128_mask pabsq256_mask pabsq512_mask pabsw128_mask pabsw256_mask pabsw512_mask phaddw256 phaddd256 phaddsw256 phsubw256 phsubd256 phsubsw256 pmaddubsw256 psignb256 psignw256 psignd256 pmulhrsw256pmulhrsw128_maskpmulhrsw256_maskpmulhrsw512_mask pmovsxbd256 pmovsxbq256 pmovsxbw256 pmovsxdq256 pmovsxwd256 pmovsxwq256 pmovzxbd256 pmovzxbq256 pmovzxbw256 pmovzxdq256 pmovzxwd256 pmovzxwq256 pblendvb256pbroadcastd512_gpr_maskpbroadcastq512_gpr_maskpbroadcastq512_mem_mask permvarsi256 permvarsf256 permti256extractf32x4_maskextracti32x4_maskextractf32x4_256_maskextracti32x4_256_maskextractf64x2_256_maskextracti64x2_256_maskextractf64x2_512_maskextracti64x2_512_maskextractf32x8_maskextracti32x8_maskextractf64x4_maskextracti64x4_maskinsertf32x4_256_maskinsertf32x4_512_maskinsertf32x8_maskinsertf64x2_256_maskinsertf64x2_512_maskinsertf64x4_maskinserti32x4_256_maskinserti32x4_512_maskinserti32x8_maskinserti64x2_256_maskinserti64x2_512_maskinserti64x4_mask maskloadd maskloadq maskloadd256 maskloadq256loaddqusi512_maskloaddqudi512_mask maskstored maskstoreq maskstored256 maskstoreq256storedqusi512_maskstoredqudi512_maskpsllv4sipsllv8sipsllv2dipsllv4dipsrlv4sipsrlv8sipsrlv2dipsrlv4dipsrav4sipsrav8sipsllv16si_mask psllv8di_maskpsrav16si_mask psrav8di_maskpsrlv16si_mask psrlv8di_mask pslldq512 psrldq512 pslld128_mask pslld256_maskpslldi128_maskpslldi256_maskpslldi512_mask psllq128_mask psllq256_maskpsllqi128_maskpsllqi256_maskpsllqi512_maskpsrav16hi_maskpsrav32hi_mask psrav4si_mask psrav8hi_mask psrav8si_maskpsravq128_maskpsravq256_maskpsrlv16hi_mask psrlv2di_maskpsrlv32hi_mask psrlv4di_mask psrlv4si_mask psrlv8hi_mask psrlv8si_maskprorvd128_maskprorvd256_maskprorvd512_maskprorvq128_maskprorvq256_maskprorvq512_mask prold128_mask prold256_mask prold512_mask prolq128_mask prolq256_mask prolq512_maskprolvd128_maskprolvd256_maskprolvd512_maskprolvq128_maskprolvq256_maskprolvq512_mask prord128_mask prord256_mask prord512_mask prorq128_mask prorq256_mask prorq512_mask gatherd_pd gatherd_pd256 gatherq_pd gatherq_pd256 gatherd_ps gatherd_ps256 gatherq_ps gatherq_ps256 gatherd_q gatherd_q256 gatherq_q gatherq_q256 gatherd_d gatherd_d256 gatherq_d gatherq_d256 pmovmskb256 pshufb256 mpsadbw256 movntdqa256vfmaddssvfmaddsdvfmaddpsvfmaddpd vfmaddps256 vfmaddpd256vfmsubssvfmsubsdvfmsubpsvfmsubpd vfmsubps256 vfmsubpd256 vfnmaddss vfnmaddsd vfnmaddps vfnmaddpd vfnmaddps256 vfnmaddpd256 vfnmsubss vfnmsubsd vfnmsubps vfnmsubpd vfnmsubps256 vfnmsubpd256 vfmaddsubps vfmaddsubpdvfmaddsubps256vfmaddsubpd256 vfmsubaddps vfmsubaddpdvfmsubaddps256vfmsubaddpd256vfmaddpd128_maskvfmaddpd128_mask3vfmaddpd128_maskzvfmaddpd256_maskvfmaddpd256_mask3vfmaddpd256_maskzvfmaddpd512_maskvfmaddpd512_mask3vfmaddpd512_maskzvfmaddps128_maskvfmaddps128_mask3vfmaddps128_maskzvfmaddps256_maskvfmaddps256_mask3vfmaddps256_maskzvfmaddps512_maskvfmaddps512_mask3vfmaddps512_maskzvfmaddsubpd128_maskvfmaddsubpd128_mask3vfmaddsubpd128_maskzvfmaddsubpd256_maskvfmaddsubpd256_mask3vfmaddsubpd256_maskzvfmaddsubpd512_maskvfmaddsubpd512_mask3vfmaddsubpd512_maskzvfmaddsubps128_maskvfmaddsubps128_mask3vfmaddsubps128_maskzvfmaddsubps256_maskvfmaddsubps256_mask3vfmaddsubps256_maskzvfmaddsubps512_maskvfmaddsubps512_mask3vfmaddsubps512_maskzvfmsubpd128_mask3vfmsubpd256_mask3vfmsubpd512_mask3vfmsubps128_mask3vfmsubps256_mask3vfmsubps512_mask3vfmsubaddpd128_mask3vfmsubaddpd256_mask3vfmsubaddpd512_mask3vfmsubaddps128_mask3vfmsubaddps256_mask3vfmsubaddps512_mask3vfnmaddpd128_maskvfnmaddpd256_maskvfnmaddpd512_maskvfnmaddps128_maskvfnmaddps256_maskvfnmaddps512_maskvfnmsubpd128_maskvfnmsubpd128_mask3vfnmsubpd256_maskvfnmsubpd256_mask3vfnmsubpd512_maskvfnmsubpd512_mask3vfnmsubps128_maskvfnmsubps128_mask3vfnmsubps256_maskvfnmsubps256_mask3vfnmsubps512_maskvfnmsubps512_mask3decomposeFromLoadcomposeFromStore signumGen cmpSelect_arrayLoopWithExitDecLoop _whileLoop _emitCode $fSelect(,,) $fSelect(,) $fSelect() $fSelectValuebasemaybe$fPhiT $fFunctorT Data.Eithereither$fMakeValueTupleVector$fMakeValueTupleStablePtr$fMakeValueTupleFunPtr$fMakeValueTuplePtr$fMakeValueTuple()$fMakeValueTupleWord64$fMakeValueTupleWord32$fMakeValueTupleWord16$fMakeValueTupleWord8$fMakeValueTupleInt64$fMakeValueTupleInt32$fMakeValueTupleInt16$fMakeValueTupleInt8$fMakeValueTupleBool$fMakeValueTupleDouble$fMakeValueTupleFloat$fMakeValueTupleEither$fMakeValueTupleMaybe$fMakeValueTuple(,,)$fMakeValueTuple(,) $fZero(,,) $fZero(,)$fZeroConstValue $fZeroValue$fZero() $fUndefinedT $fUndefinedT0$fUndefined(,,)$fUndefined(,)$fUndefinedConstValue$fUndefinedValue $fUndefined() insertvalue extractvalue _cumulate1s switchFPPred pcmpuFromPcmp valueUnitmask _mapByFolddotProductPartialreduceSumInterleavedfractionGeneric _floorSelect_fractionSelect selectLogicalMaskableMask replicateCore iterateCoreconstCyclicVector extractList mapChunks2zipChunks2With withRound sumPartialchopCore getLowestPair_reduceAddInterleaved sumGenericsumToPairGeneric_cumulateSimplecumulateGeneric cumulateFrom1inttofp signumLogicalsignumIntGenericsignumWordGenericsignumFloatGeneric floorGenericmakeMask minGeneric maxGeneric absGenericabsAuto floorLogicalfractionLogicalorder constVector4 $fRealWord64 $fRealWord32 $fRealWord16 $fRealWord8 $fRealInt64 $fRealInt32 $fRealInt16 $fRealInt8 $fRealDouble $fRealFloat$fArithmeticWord32$fArithmeticWord64$fArithmeticWord16$fArithmeticWord8$fArithmeticInt64$fArithmeticInt32$fArithmeticInt16$fArithmeticInt8$fArithmeticDouble$fArithmeticFloat$fMaskableDouble$fMaskableFloat$fMaskableWord64$fMaskableWord32$fMaskableWord16$fMaskableWord8$fMaskableInt64$fMaskableInt32$fMaskableInt16$fMaskableInt8$fCanonicaln(,,)$fCanonicaln(,)$fCanonicalnValue$fSimpleConstant$fUndefinedConstant $fPhiConstant$fTraversableConstant$fFoldableConstant$fApplicativeConstant$fFunctorConstant$fC(,,) $fSimple(,,)$fC(,) $fSimple(,)$fCValue $fSimpleValue runScalar fractionGenintratio singletonmapAuto zipAutoWith$fTranscendentalConstantVector$fTranscendentalConstantDouble$fTranscendentalConstantFloat$fRationalConstantVector$fRationalConstantDouble$fRationalConstantFloat$fIntegerConstantVector$fIntegerConstantDouble$fIntegerConstantFloat$fIntegerConstantInt64$fIntegerConstantInt32$fIntegerConstantInt16$fIntegerConstantInt8$fIntegerConstantWord64$fIntegerConstantWord32$fIntegerConstantWord16$fIntegerConstantWord8$fPseudoModuleVector$fPseudoModuleDouble$fPseudoModuleFloat$fPseudoModuleInt64$fPseudoModuleInt32$fPseudoModuleInt16$fPseudoModuleInt8$fPseudoModuleWord64$fPseudoModuleWord32$fPseudoModuleWord16$fPseudoModuleWord8 $fRealVector $fRealFP128$fReplicateVector$fReplicateWord64$fReplicateWord32$fReplicateWord16$fReplicateWord8$fReplicateInt64$fReplicateInt32$fReplicateInt16$fReplicateInt8$fReplicateBool$fReplicateFP128$fReplicateDouble$fReplicateFloat$fFractionVector$fFractionDouble$fFractionFloatGHC.Realquot_inc_dec valueTypeNamecallIntrinsic1callIntrinsic2 addReadNone$fTranscendentalValue$fAlgebraicValue$fLogicConstValue $fLogicValue$fFloatingComparisonConstValue$fFloatingComparisonValue$fComparisonConstValue$fComparisonValue$fFractionValue $fRealValue$fRationalConstantValue$fRationalConstantConstValue$fFieldConstValue $fFieldValue$fIntegerConstantValue$fIntegerConstantConstValue$fPseudoModuleConstValue$fPseudoModuleValue$fPseudoRingConstValue$fPseudoRingValue$fAdditive(,,) $fAdditive(,)$fAdditiveConstValue$fAdditiveValue$fIntegralInt64$fIntegralInt32$fIntegralWord64$fIntegralWord32$fLogicT $fLogicBool$fFloatingComparisonT$fFloatingComparisonFloat $fComparisonT$fComparisonWord64$fComparisonWord32$fComparisonWord16$fComparisonWord8$fComparisonInt64$fComparisonInt32$fComparisonInt16$fComparisonInt8$fComparisonDouble$fComparisonFloat $fSelectT $fSelectInt64 $fSelectInt32 $fSelectInt16 $fSelectInt8$fSelectWord64$fSelectWord32$fSelectWord16 $fSelectWord8$fSelectDouble $fSelectFloat$fTranscendentalT$fTranscendentalDouble$fTranscendentalFloat $fAlgebraicT$fAlgebraicDouble$fAlgebraicFloat$fNativeFloatingDoubleDouble$fNativeFloatingFloatFloat$fNativeIntegerInt64Int64$fNativeIntegerInt32Int32$fNativeIntegerInt16Int16$fNativeIntegerInt8Int8$fNativeIntegerWord64Word64$fNativeIntegerWord32Word32$fNativeIntegerWord16Word16$fNativeIntegerWord8Word8 $fFractionT$fRealT$fPseudoModuleT$fFieldT $fFieldDouble $fFieldFloat $fPseudoRingT$fPseudoRingInt64$fPseudoRingInt32$fPseudoRingInt16$fPseudoRingInt8$fPseudoRingWord64$fPseudoRingWord32$fPseudoRingWord16$fPseudoRingWord8$fPseudoRingDouble$fPseudoRingFloat $fAdditiveT$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveDouble$fAdditiveFloat$fRationalConstantT$fIntegerConstantT$fZeroT$fDecompose(,,,)$fCompose(,,,)$fDecompose(,,) $fCompose(,,)$fDecompose(,) $fCompose(,) $fDecompose() $fCompose()$fDecomposeAtom $fComposeT$fC(,,,)$fC() $fCStablePtr $fCFunPtr$fCPtr$fCInt64$fCInt32$fCInt16$fCInt8 $fCWord64 $fCWord32 $fCWord16$fCWord8 $fCDouble$fCFloat$fCBool PrimValue_liftM0$fCn(,) $fCnDouble $fCnFloat ConvertStructdecomposeField composeField StoredStruct fromStorable toStorable loadElement storeElementextractElement insertElementpairtriplefieldsdecSucc$fCT$fCT0$fConvertStructsi()$fConvertStructsi(,)$fFirstClassStruct$fFirstClassStablePtr$fFirstClassFunPtr$fFirstClassPtr$fFirstClassArray$fFirstClassVector$fFirstClassBool$fFirstClassWord64$fFirstClassWord32$fFirstClassWord16$fFirstClassWord8$fFirstClassInt64$fFirstClassInt32$fFirstClassInt16$fFirstClassInt8$fFirstClassDouble$fFirstClassFloat$fCT1$fCT2$fCT3$fApplicativeElement$fFunctorElementNothingJust $fMonadIOT$fMonadT$fApplicativeT