diff --git a/GHC/CString.hs b/GHC/CString.hs --- a/GHC/CString.hs +++ b/GHC/CString.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE MagicHash, NoImplicitPrelude, BangPatterns #-} +{-# LANGUAGE MagicHash, NoImplicitPrelude, BangPatterns, UnliftedFFITypes #-} ----------------------------------------------------------------------------- -- | -- Module : GHC.CString @@ -16,13 +16,78 @@ ----------------------------------------------------------------------------- module GHC.CString ( + -- * Ascii variants unpackCString#, unpackAppendCString#, unpackFoldrCString#, - unpackCStringUtf8#, unpackNBytes# + cstringLength#, + + -- * Utf variants + unpackCStringUtf8#, unpackAppendCStringUtf8#, unpackFoldrCStringUtf8#, + + -- * Other + unpackNBytes#, ) where -import GHC.Types +import GHC.Types hiding (One) import GHC.Prim +{- +Note [String literals in GHC] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +String literals get quite a bit of special handling in GHC. This Note +summarises the moving parts. + +* Desugaring: see GHC.HsToCore.Match.Literal.dsLit, which in + turn calls GHC.Core.Make.mkStringExprFS. + + The desugarer desugars the Haskell literal "foo" into Core + GHC.CString.unpackCString# "foo"# + where "foo"# is primitive string literal (of type Addr#). + + When the string cannot be encoded as a C string, we use UTF8: + GHC.CString.unpackCStringUtf8# "foo"# + +* The library module ghc-prim:GHC.CString has a bunch of functions that + work over primitive strings, including GHC.CString.unpackCString# + +* GHC.Core.Op.ConstantFold has some RULES that optimise certain string + operations on literal strings. For example: + + + Constant folding the desugared form of ("foo" ++ "bar") + into ("foobar") + + Comparing strings + + and more + +* GHC.Base has a number of regular rules for String literals. + + + a rule "eqString": (==) @String = eqString + where GHC.Base.eqString :: String -> String -> Bool + + ConstantFold has a RULE for eqString on literals: + eqString (Lit "foo"#) (Lit "bar"#) --> False + + This allows compile time evaluation of things like "foo" == "bar" + + + A bunch of rules to promote fusion: + + "unpack" [~1] forall a . unpackCString# a = build (unpackFoldrCString# a) + "unpack-list" [1] forall a . unpackFoldrCString# a (:) [] = unpackCString# a + "unpack-append" forall a n . unpackFoldrCString# a (:) n = unpackAppendCString# a n + + And UTF8 variants of these rules. + +* We allow primitive (unlifted) literal strings to be top-level + bindings, breaking out usual rule. See GHC.Core + Note [Core top-level string literals] + +* TODO: There is work on a special code-gen path for top-level boxed strings + str :: [Char] + str = unpackCString# "foo"# + so that they can all share a common code pointer + + There is a WIP MR on gitlab for this: !3012 + +-} + ----------------------------------------------------------------------------- -- Unpacking C strings ----------------------------------------------------------------------------- @@ -45,7 +110,7 @@ Moreover, inlining early may interfere with a variety of rules that are supposed to match unpackCString#, - * BuiltInRules in PrelRules.hs; e.g. + * BuiltInRules in GHC.Core.Opt.ConstantFold; e.g. eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2) = s1 == s2 @@ -59,8 +124,8 @@ Moreover, we want to make it CONLIKE, so that: -* the rules in PrelRules will fire when the string is let-bound. - E.g. the eqString rule in PrelRules +* the rules in GHC.Core.Opt.ConstantFold will fire when the string is let-bound. + E.g. the eqString rule in GHC.Core.Opt.ConstantFold eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2) = s1==s2 * exprIsConApp_maybe will see the string when we have @@ -70,85 +135,129 @@ All of this goes for unpackCStringUtf8# too. -} +{- Note [Inlining of unpackFoldrCString] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Usually the unpack-list rule turns unpackFoldrCString# into unpackCString# +It also has a BuiltInRule in PrelRules.hs: + unpackFoldrCString# "foo" c (unpackFoldrCString# "baz" c n) + = unpackFoldrCString# "foobaz" c n + +We use NOINLINE [0] on the grounds that, unlike +unpackCString#, there *is* some point in inlining +unpackFoldrCString#, because we get better code for the +higher-order function call. + +This can cause a code size increase but it was minimal +when looking at nofib. + +This is especially important for elem which then results in an +allocation free loop. + + Note [unpackCString# iterating over addr] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +When unpacking unpackCString# and friends repeatedly return a cons cell +containing: +* The current character we just unpacked. +* A thunk to unpack the rest of the string. + +In order to minimize the size of the thunk we do not index of +the start of the string, offsetting into it, but instead increment +the addr and always use offset 0#. + +This works since these two expressions will read from the same address. +* `indexCharOffAddr# a i` +* `indexCharOffAddr (a `plusAddr#` i) 0#` + +This way we avoid the need for the thunks to close over both the start of +the string and the current offset, saving a word for each character unpacked. + +This has the additional advantage the we can guarantee that only the +increment will happen in the loop. + +-} + unpackCString# :: Addr# -> [Char] {-# NOINLINE CONLIKE unpackCString# #-} unpackCString# addr - = unpack 0# - where - unpack nh - | isTrue# (ch `eqChar#` '\0'#) = [] - | True = C# ch : unpack (nh +# 1#) + | isTrue# (ch `eqChar#` '\0'#) = [] + | True = C# ch : unpackCString# (addr `plusAddr#` 1#) where - !ch = indexCharOffAddr# addr nh + -- See Note [unpackCString# iterating over addr] + !ch = indexCharOffAddr# addr 0# + unpackAppendCString# :: Addr# -> [Char] -> [Char] {-# NOINLINE unpackAppendCString# #-} -- See the NOINLINE note on unpackCString# unpackAppendCString# addr rest - = unpack 0# - where - unpack nh - | isTrue# (ch `eqChar#` '\0'#) = rest - | True = C# ch : unpack (nh +# 1#) + | isTrue# (ch `eqChar#` '\0'#) = rest + | True = C# ch : unpackAppendCString# (addr `plusAddr#` 1#) rest where - !ch = indexCharOffAddr# addr nh - -unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a - --- Usually the unpack-list rule turns unpackFoldrCString# into unpackCString# - --- It also has a BuiltInRule in PrelRules.hs: --- unpackFoldrCString# "foo" c (unpackFoldrCString# "baz" c n) --- = unpackFoldrCString# "foobaz" c n - -{-# NOINLINE unpackFoldrCString# #-} --- At one stage I had NOINLINE [0] on the grounds that, unlike --- unpackCString#, there *is* some point in inlining --- unpackFoldrCString#, because we get better code for the --- higher-order function call. BUT there may be a lot of --- literal strings, and making a separate 'unpack' loop for --- each is highly gratuitous. See nofib/real/anna/PrettyPrint. + -- See Note [unpackCString# iterating over addr] + !ch = indexCharOffAddr# addr 0# -unpackFoldrCString# addr f z - = unpack 0# +-- Usually the unpack-list rule turns unpackFoldrCString# into unpackCString#. +-- See Note [String literals in GHC] for more details. +-- See [Inlining of unpackFoldrCString] +{-# NOINLINE[0] unpackFoldrCString# #-} +unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a +unpackFoldrCString# str f z_init = go str z_init where - unpack nh + go addr z | isTrue# (ch `eqChar#` '\0'#) = z - | True = C# ch `f` unpack (nh +# 1#) + | True = C# ch `f` go (addr `plusAddr#` 1#) z where - !ch = indexCharOffAddr# addr nh + -- See Note [unpackCString# iterating over addr] + !ch = indexCharOffAddr# addr 0# -- There's really no point in inlining this for the same reasons as -- unpackCString. See Note [Inlining unpackCString#] above for details. unpackCStringUtf8# :: Addr# -> [Char] {-# NOINLINE CONLIKE unpackCStringUtf8# #-} unpackCStringUtf8# addr - = unpack 0# + | isTrue# (ch `eqChar#` '\0'# ) = [] + | True = + let !byte_count = getByteCount ch + !utf_ch = unpackUtf8Char# byte_count ch addr + !addr' = addr `plusBytes` byte_count + in C# utf_ch : unpackCStringUtf8# addr' + where + -- See Note [unpackCString# iterating over addr] + !ch = indexCharOffAddr# addr 0# + + +unpackAppendCStringUtf8# :: Addr# -> [Char] -> [Char] +{-# NOINLINE unpackAppendCStringUtf8# #-} + -- See the NOINLINE note on unpackCString# +unpackAppendCStringUtf8# addr rest + | isTrue# (ch `eqChar#` '\0'#) = rest + | True = + let !byte_count = getByteCount ch + !utf_ch = unpackUtf8Char# byte_count ch addr + !addr' = (addr `plusBytes` byte_count) + in C# utf_ch : unpackAppendCStringUtf8# addr' rest + where + -- See Note [unpackCString# iterating over addr] + !ch = indexCharOffAddr# addr 0# + +-- See Note [Inlining of unpackFoldrCString] +{-# NOINLINE[0] unpackFoldrCStringUtf8# #-} +unpackFoldrCStringUtf8# :: Addr# -> (Char -> a -> a) -> a -> a +unpackFoldrCStringUtf8# addr_init f z_init + = go addr_init z_init where - -- We take care to strictly evaluate the character decoding as - -- indexCharOffAddr# is marked with the can_fail flag and - -- consequently GHC won't evaluate the expression unless it is absolutely - -- needed. - unpack nh - | isTrue# (ch `eqChar#` '\0'# ) = [] - | isTrue# (ch `leChar#` '\x7F'#) = C# ch : unpack (nh +# 1#) - | isTrue# (ch `leChar#` '\xDF'#) = - let !c = C# (chr# (((ord# ch -# 0xC0#) `uncheckedIShiftL#` 6#) +# - (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#))) - in c : unpack (nh +# 2#) - | isTrue# (ch `leChar#` '\xEF'#) = - let !c = C# (chr# (((ord# ch -# 0xE0#) `uncheckedIShiftL#` 12#) +# - ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#` 6#) +# - (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#))) - in c : unpack (nh +# 3#) - | True = - let !c = C# (chr# (((ord# ch -# 0xF0#) `uncheckedIShiftL#` 18#) +# - ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#` 12#) +# - ((ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#) `uncheckedIShiftL#` 6#) +# - (ord# (indexCharOffAddr# addr (nh +# 3#)) -# 0x80#))) - in c : unpack (nh +# 4#) + go addr z + | isTrue# (ch `eqChar#` '\0'#) = z + | True = + let !byte_count = getByteCount ch + !utf_ch = unpackUtf8Char# byte_count ch addr + !addr' = (addr `plusBytes` byte_count) + in C# utf_ch `f` go addr' z where - !ch = indexCharOffAddr# addr nh + -- See Note [unpackCString# iterating over addr] + !ch = indexCharOffAddr# addr 0# -- There's really no point in inlining this for the same reasons as -- unpackCString. See Note [Inlining unpackCString#] above for details. @@ -157,9 +266,82 @@ unpackNBytes# _addr 0# = [] unpackNBytes# addr len# = unpack [] (len# -# 1#) where + unpack :: [Char] -> Int# -> [Char] unpack acc i# | isTrue# (i# <# 0#) = acc | True = case indexCharOffAddr# addr i# of ch -> unpack (C# ch : acc) (i# -# 1#) +-- The return type is not correct here. We really want CSize, +-- but that type is defined in base. However, CSize should always +-- match the size of a machine word (I hope), so this is probably +-- alright on all platforms that GHC supports. +foreign import ccall unsafe "strlen" c_strlen :: Addr# -> Int# + +-- | Compute the length of a NUL-terminated string. This address +-- must refer to immutable memory. GHC includes a built-in rule for +-- constant folding when the argument is a statically-known literal. +-- That is, a core-to-core pass reduces the expression +-- @cstringLength# "hello"#@ to the constant @5#@. +cstringLength# :: Addr# -> Int# +{-# INLINE[0] cstringLength# #-} +cstringLength# = c_strlen + + +------------------------------ +--- UTF8 decoding utilities +------------------------------ +-- +-- These functions make explicit the logic that was originally +-- part of unpackCStringUtf8. Since we want the same support for ascii +-- and non-ascii a variety of functions needs the same logic. Instead +-- of C&P'in the decoding logic all over we have it here once, and then +-- force GHC to inline it. +-- +-- All the overhead of the Bytes argument and calls goes away once all is +-- said and done. And what remains is readable code in Haskell land and +-- performant code in the resulting binary. + +data Bytes = One | Two | Three | Four + +{-# INLINE getByteCount #-} +getByteCount :: Char# -> Bytes +getByteCount ch + | isTrue# (ch `leChar#` '\x7F'#) = One + | isTrue# (ch `leChar#` '\xDF'#) = Two + | isTrue# (ch `leChar#` '\xEF'#) = Three + | True = Four + +{-# INLINE plusBytes #-} +plusBytes :: Addr# -> Bytes -> Addr# +plusBytes addr bytes = + case bytes of + One -> addr `plusAddr#` 1# + Two -> addr `plusAddr#` 2# + Three -> addr `plusAddr#` 3# + Four -> addr `plusAddr#` 4# + +-- | Take the current address, read unicode char of the given size. +-- We obviously want the number of bytes, but we have to read one +-- byte to determine the number of bytes for the current codepoint +-- so we might as well reuse it and avoid a read. +-- +-- Side Note: We don't dare to decode all 4 possibilities at once. +-- Reading past the end of the addr might trigger an exception. +-- For this reason we really have to check the width first and only +-- decode after. +{-# INLINE unpackUtf8Char# #-} +unpackUtf8Char# :: Bytes -> Char# -> Addr# -> Char# +unpackUtf8Char# bytes ch addr = + case bytes of + One -> ch + Two -> (chr# (((ord# ch -# 0xC0#) `uncheckedIShiftL#` 6#) +# + (ord# (indexCharOffAddr# (addr `plusAddr#` 1#) 0#) -# 0x80#))) + Three -> (chr# (((ord# ch -# 0xE0#) `uncheckedIShiftL#` 12#) +# + ((ord# (indexCharOffAddr# (addr `plusAddr#` 1#) 0#) -# 0x80#) `uncheckedIShiftL#` 6#) +# + (ord# (indexCharOffAddr# (addr `plusAddr#` 2#) 0#) -# 0x80#))) + Four -> (chr# (((ord# ch -# 0xF0#) `uncheckedIShiftL#` 18#) +# + ((ord# (indexCharOffAddr# (addr `plusAddr#` 1#) 0#) -# 0x80#) `uncheckedIShiftL#` 12#) +# + ((ord# (indexCharOffAddr# (addr `plusAddr#` 2#) 0#) -# 0x80#) `uncheckedIShiftL#` 6#) +# + (ord# (indexCharOffAddr# (addr `plusAddr#` 3#) 0#) -# 0x80#))) diff --git a/GHC/Magic.hs b/GHC/Magic.hs --- a/GHC/Magic.hs +++ b/GHC/Magic.hs @@ -27,7 +27,7 @@ module GHC.Magic ( inline, noinline, lazy, oneShot, runRW# ) where -------------------------------------------------- --- See Note [magicIds] in MkId.hs +-- See Note [magicIds] in GHC.Types.Id.Make -------------------------------------------------- -- Here import TYPE explicitly from GHC.Types and not from GHC.Prim. This is @@ -88,7 +88,7 @@ lazy :: a -> a lazy x = x -- Implementation note: its strictness and unfolding are over-ridden --- by the definition in MkId.hs; in both cases to nothing at all. +-- by the definition in GHC.Types.Id.Make; in both cases to nothing at all. -- That way, 'lazy' does not get inlined, and the strictness analyser -- sees it as lazy. Then the worker/wrapper phase inlines it. -- Result: happiness @@ -109,7 +109,7 @@ (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b oneShot f = f --- Implementation note: This is wired in in MkId.hs, so the code here is +-- Implementation note: This is wired in in GHC.Types.Id.Make, so the code here is -- mostly there to have a place for the documentation. -- | Apply a function to a @'State#' 'RealWorld'@ token. When manually applying @@ -122,7 +122,7 @@ runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). (State# RealWorld -> o) -> o --- See Note [runRW magic] in CorePrep +-- See Note [runRW magic] in GHC.CoreToStg.Prep. {-# NOINLINE runRW# #-} -- runRW# is inlined manually in CorePrep #if !defined(__HADDOCK_VERSION__) runRW# m = m realWorld# diff --git a/GHC/Prim.hs b/GHC/Prim.hs deleted file mode 100644 --- a/GHC/Prim.hs +++ /dev/null @@ -1,8546 +0,0 @@ -{- -This is a generated file (generated by genprimopcode). -It is not code to actually be used. Its only purpose is to be -consumed by haddock. --} - ------------------------------------------------------------------------------ --- | --- Module : GHC.Prim --- --- Maintainer : ghc-devs@haskell.org --- Stability : internal --- Portability : non-portable (GHC extensions) --- --- GHC's primitive types and operations. --- Use GHC.Exts from the base package instead of importing this --- module directly. --- ------------------------------------------------------------------------------ -{-# LANGUAGE Unsafe #-} -{-# LANGUAGE MagicHash #-} -{-# LANGUAGE MultiParamTypeClasses #-} -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE UnboxedTuples #-} -{-# LANGUAGE NegativeLiterals #-} -{-# OPTIONS_GHC -fno-warn-redundant-constraints #-} -module GHC.Prim ( - --- * The word size story. --- |Haskell98 specifies that signed integers (type @Int@) --- must contain at least 30 bits. GHC always implements @Int@ using the primitive type @Int\#@, whose size equals --- the @MachDeps.h@ constant @WORD\_SIZE\_IN\_BITS@. --- This is normally set based on the @config.h@ parameter --- @SIZEOF\_HSWORD@, i.e., 32 bits on 32-bit machines, 64 --- bits on 64-bit machines. However, it can also be explicitly --- set to a smaller number than 64, e.g., 62 bits, to allow the --- possibility of using tag bits. Currently GHC itself has only --- 32-bit and 64-bit variants, but 61, 62, or 63-bit code can be --- exported as an external core file for use in other back ends. --- 30 and 31-bit code is no longer supported. --- --- GHC also implements a primitive unsigned integer type @Word\#@ which always has the same number of bits as @Int\#@. --- --- In addition, GHC supports families of explicit-sized integers --- and words at 8, 16, 32, and 64 bits, with the usual --- arithmetic operations, comparisons, and a range of --- conversions. The 8-bit and 16-bit sizes are always --- represented as @Int\#@ and @Word\#@, and the --- operations implemented in terms of the primops on these --- types, with suitable range restrictions on the results (using --- the @narrow$n$Int\#@ and @narrow$n$Word\#@ families --- of primops. The 32-bit sizes are represented using @Int\#@ and @Word\#@ when @WORD\_SIZE\_IN\_BITS@ --- $\geq$ 32; otherwise, these are represented using distinct --- primitive types @Int32\#@ and @Word32\#@. These (when --- needed) have a complete set of corresponding operations; --- however, nearly all of these are implemented as external C --- functions rather than as primops. Exactly the same story --- applies to the 64-bit sizes. All of these details are hidden --- under the @PrelInt@ and @PrelWord@ modules, which use --- @\#if@-defs to invoke the appropriate types and --- operators. --- --- Word size also matters for the families of primops for --- indexing\/reading\/writing fixed-size quantities at offsets --- from an array base, address, or foreign pointer. Here, a --- slightly different approach is taken. The names of these --- primops are fixed, but their /types/ vary according to --- the value of @WORD\_SIZE\_IN\_BITS@. For example, if word --- size is at least 32 bits then an operator like --- @indexInt32Array\#@ has type @ByteArray\# -> Int\# -> Int\#@; otherwise it has type @ByteArray\# -> Int\# -> Int32\#@. This approach confines the necessary @\#if@-defs to this file; no conditional compilation is needed --- in the files that expose these primops. --- --- Finally, there are strongly deprecated primops for coercing --- between @Addr\#@, the primitive type of machine --- addresses, and @Int\#@. These are pretty bogus anyway, --- but will work on existing 32-bit and 64-bit GHC targets; they --- are completely bogus when tag bits are used in @Int\#@, --- so are not available in this case. - - - --- * Char# --- |Operations on 31-bit characters. - - Char#, - gtChar#, - geChar#, - eqChar#, - neChar#, - ltChar#, - leChar#, - ord#, - --- * Int# --- |Operations on native-size integers (32+ bits). - - Int#, - (+#), - (-#), - (*#), - mulIntMayOflo#, - quotInt#, - remInt#, - quotRemInt#, - andI#, - orI#, - xorI#, - notI#, - negateInt#, - addIntC#, - subIntC#, - (>#), - (>=#), - (==#), - (/=#), - (<#), - (<=#), - chr#, - int2Word#, - int2Float#, - int2Double#, - word2Float#, - word2Double#, - uncheckedIShiftL#, - uncheckedIShiftRA#, - uncheckedIShiftRL#, - --- * Int8# --- |Operations on 8-bit integers. - - Int8#, - extendInt8#, - narrowInt8#, - negateInt8#, - plusInt8#, - subInt8#, - timesInt8#, - quotInt8#, - remInt8#, - quotRemInt8#, - eqInt8#, - geInt8#, - gtInt8#, - leInt8#, - ltInt8#, - neInt8#, - --- * Word8# --- |Operations on 8-bit unsigned integers. - - Word8#, - extendWord8#, - narrowWord8#, - notWord8#, - plusWord8#, - subWord8#, - timesWord8#, - quotWord8#, - remWord8#, - quotRemWord8#, - eqWord8#, - geWord8#, - gtWord8#, - leWord8#, - ltWord8#, - neWord8#, - --- * Int16# --- |Operations on 16-bit integers. - - Int16#, - extendInt16#, - narrowInt16#, - negateInt16#, - plusInt16#, - subInt16#, - timesInt16#, - quotInt16#, - remInt16#, - quotRemInt16#, - eqInt16#, - geInt16#, - gtInt16#, - leInt16#, - ltInt16#, - neInt16#, - --- * Word16# --- |Operations on 16-bit unsigned integers. - - Word16#, - extendWord16#, - narrowWord16#, - notWord16#, - plusWord16#, - subWord16#, - timesWord16#, - quotWord16#, - remWord16#, - quotRemWord16#, - eqWord16#, - geWord16#, - gtWord16#, - leWord16#, - ltWord16#, - neWord16#, - --- * Word# --- |Operations on native-sized unsigned words (32+ bits). - - Word#, - plusWord#, - addWordC#, - subWordC#, - plusWord2#, - minusWord#, - timesWord#, - timesWord2#, - quotWord#, - remWord#, - quotRemWord#, - quotRemWord2#, - and#, - or#, - xor#, - not#, - uncheckedShiftL#, - uncheckedShiftRL#, - word2Int#, - gtWord#, - geWord#, - eqWord#, - neWord#, - ltWord#, - leWord#, - popCnt8#, - popCnt16#, - popCnt32#, - popCnt64#, - popCnt#, - pdep8#, - pdep16#, - pdep32#, - pdep64#, - pdep#, - pext8#, - pext16#, - pext32#, - pext64#, - pext#, - clz8#, - clz16#, - clz32#, - clz64#, - clz#, - ctz8#, - ctz16#, - ctz32#, - ctz64#, - ctz#, - byteSwap16#, - byteSwap32#, - byteSwap64#, - byteSwap#, - bitReverse8#, - bitReverse16#, - bitReverse32#, - bitReverse64#, - bitReverse#, - --- * Narrowings --- |Explicit narrowing of native-sized ints or words. - - narrow8Int#, - narrow16Int#, - narrow32Int#, - narrow8Word#, - narrow16Word#, - narrow32Word#, - --- * Double# --- |Operations on double-precision (64 bit) floating-point numbers. - - Double#, - (>##), - (>=##), - (==##), - (/=##), - (<##), - (<=##), - (+##), - (-##), - (*##), - (/##), - negateDouble#, - fabsDouble#, - double2Int#, - double2Float#, - expDouble#, - expm1Double#, - logDouble#, - log1pDouble#, - sqrtDouble#, - sinDouble#, - cosDouble#, - tanDouble#, - asinDouble#, - acosDouble#, - atanDouble#, - sinhDouble#, - coshDouble#, - tanhDouble#, - asinhDouble#, - acoshDouble#, - atanhDouble#, - (**##), - decodeDouble_2Int#, - decodeDouble_Int64#, - --- * Float# --- |Operations on single-precision (32-bit) floating-point numbers. - - Float#, - gtFloat#, - geFloat#, - eqFloat#, - neFloat#, - ltFloat#, - leFloat#, - plusFloat#, - minusFloat#, - timesFloat#, - divideFloat#, - negateFloat#, - fabsFloat#, - float2Int#, - expFloat#, - expm1Float#, - logFloat#, - log1pFloat#, - sqrtFloat#, - sinFloat#, - cosFloat#, - tanFloat#, - asinFloat#, - acosFloat#, - atanFloat#, - sinhFloat#, - coshFloat#, - tanhFloat#, - asinhFloat#, - acoshFloat#, - atanhFloat#, - powerFloat#, - float2Double#, - decodeFloat_Int#, - --- * Arrays --- |Operations on @Array\#@. - - Array#, - MutableArray#, - newArray#, - sameMutableArray#, - readArray#, - writeArray#, - sizeofArray#, - sizeofMutableArray#, - indexArray#, - unsafeFreezeArray#, - unsafeThawArray#, - copyArray#, - copyMutableArray#, - cloneArray#, - cloneMutableArray#, - freezeArray#, - thawArray#, - casArray#, - --- * Small Arrays --- |Operations on @SmallArray\#@. A @SmallArray\#@ works --- just like an @Array\#@, but with different space use and --- performance characteristics (that are often useful with small --- arrays). The @SmallArray\#@ and @SmallMutableArray#@ --- lack a \`card table\'. The purpose of a card table is to avoid --- having to scan every element of the array on each GC by --- keeping track of which elements have changed since the last GC --- and only scanning those that have changed. So the consequence --- of there being no card table is that the representation is --- somewhat smaller and the writes are somewhat faster (because --- the card table does not need to be updated). The disadvantage --- of course is that for a @SmallMutableArray#@ the whole --- array has to be scanned on each GC. Thus it is best suited for --- use cases where the mutable array is not long lived, e.g. --- where a mutable array is initialised quickly and then frozen --- to become an immutable @SmallArray\#@. --- - - SmallArray#, - SmallMutableArray#, - newSmallArray#, - sameSmallMutableArray#, - shrinkSmallMutableArray#, - readSmallArray#, - writeSmallArray#, - sizeofSmallArray#, - sizeofSmallMutableArray#, - getSizeofSmallMutableArray#, - indexSmallArray#, - unsafeFreezeSmallArray#, - unsafeThawSmallArray#, - copySmallArray#, - copySmallMutableArray#, - cloneSmallArray#, - cloneSmallMutableArray#, - freezeSmallArray#, - thawSmallArray#, - casSmallArray#, - --- * Byte Arrays --- |Operations on @ByteArray\#@. A @ByteArray\#@ is a just a region of --- raw memory in the garbage-collected heap, which is not --- scanned for pointers. It carries its own size (in bytes). --- There are --- three sets of operations for accessing byte array contents: --- index for reading from immutable byte arrays, and read\/write --- for mutable byte arrays. Each set contains operations for a --- range of useful primitive data types. Each operation takes --- an offset measured in terms of the size of the primitive type --- being read or written. - - ByteArray#, - MutableByteArray#, - newByteArray#, - newPinnedByteArray#, - newAlignedPinnedByteArray#, - isMutableByteArrayPinned#, - isByteArrayPinned#, - byteArrayContents#, - sameMutableByteArray#, - shrinkMutableByteArray#, - resizeMutableByteArray#, - unsafeFreezeByteArray#, - sizeofByteArray#, - sizeofMutableByteArray#, - getSizeofMutableByteArray#, - indexCharArray#, - indexWideCharArray#, - indexIntArray#, - indexWordArray#, - indexAddrArray#, - indexFloatArray#, - indexDoubleArray#, - indexStablePtrArray#, - indexInt8Array#, - indexInt16Array#, - indexInt32Array#, - indexInt64Array#, - indexWord8Array#, - indexWord16Array#, - indexWord32Array#, - indexWord64Array#, - indexWord8ArrayAsChar#, - indexWord8ArrayAsWideChar#, - indexWord8ArrayAsAddr#, - indexWord8ArrayAsFloat#, - indexWord8ArrayAsDouble#, - indexWord8ArrayAsStablePtr#, - indexWord8ArrayAsInt16#, - indexWord8ArrayAsInt32#, - indexWord8ArrayAsInt64#, - indexWord8ArrayAsInt#, - indexWord8ArrayAsWord16#, - indexWord8ArrayAsWord32#, - indexWord8ArrayAsWord64#, - indexWord8ArrayAsWord#, - readCharArray#, - readWideCharArray#, - readIntArray#, - readWordArray#, - readAddrArray#, - readFloatArray#, - readDoubleArray#, - readStablePtrArray#, - readInt8Array#, - readInt16Array#, - readInt32Array#, - readInt64Array#, - readWord8Array#, - readWord16Array#, - readWord32Array#, - readWord64Array#, - readWord8ArrayAsChar#, - readWord8ArrayAsWideChar#, - readWord8ArrayAsAddr#, - readWord8ArrayAsFloat#, - readWord8ArrayAsDouble#, - readWord8ArrayAsStablePtr#, - readWord8ArrayAsInt16#, - readWord8ArrayAsInt32#, - readWord8ArrayAsInt64#, - readWord8ArrayAsInt#, - readWord8ArrayAsWord16#, - readWord8ArrayAsWord32#, - readWord8ArrayAsWord64#, - readWord8ArrayAsWord#, - writeCharArray#, - writeWideCharArray#, - writeIntArray#, - writeWordArray#, - writeAddrArray#, - writeFloatArray#, - writeDoubleArray#, - writeStablePtrArray#, - writeInt8Array#, - writeInt16Array#, - writeInt32Array#, - writeInt64Array#, - writeWord8Array#, - writeWord16Array#, - writeWord32Array#, - writeWord64Array#, - writeWord8ArrayAsChar#, - writeWord8ArrayAsWideChar#, - writeWord8ArrayAsAddr#, - writeWord8ArrayAsFloat#, - writeWord8ArrayAsDouble#, - writeWord8ArrayAsStablePtr#, - writeWord8ArrayAsInt16#, - writeWord8ArrayAsInt32#, - writeWord8ArrayAsInt64#, - writeWord8ArrayAsInt#, - writeWord8ArrayAsWord16#, - writeWord8ArrayAsWord32#, - writeWord8ArrayAsWord64#, - writeWord8ArrayAsWord#, - compareByteArrays#, - copyByteArray#, - copyMutableByteArray#, - copyByteArrayToAddr#, - copyMutableByteArrayToAddr#, - copyAddrToByteArray#, - setByteArray#, - atomicReadIntArray#, - atomicWriteIntArray#, - casIntArray#, - fetchAddIntArray#, - fetchSubIntArray#, - fetchAndIntArray#, - fetchNandIntArray#, - fetchOrIntArray#, - fetchXorIntArray#, - --- * Arrays of arrays --- |Operations on @ArrayArray\#@. An @ArrayArray\#@ contains references to /unpointed/ --- arrays, such as @ByteArray\#s@. Hence, it is not parameterised by the element types, --- just like a @ByteArray\#@, but it needs to be scanned during GC, just like an @Array\#@. --- We represent an @ArrayArray\#@ exactly as a @Array\#@, but provide element-type-specific --- indexing, reading, and writing. - - ArrayArray#, - MutableArrayArray#, - newArrayArray#, - sameMutableArrayArray#, - unsafeFreezeArrayArray#, - sizeofArrayArray#, - sizeofMutableArrayArray#, - indexByteArrayArray#, - indexArrayArrayArray#, - readByteArrayArray#, - readMutableByteArrayArray#, - readArrayArrayArray#, - readMutableArrayArrayArray#, - writeByteArrayArray#, - writeMutableByteArrayArray#, - writeArrayArrayArray#, - writeMutableArrayArrayArray#, - copyArrayArray#, - copyMutableArrayArray#, - --- * Addr# --- | - - Addr#, - nullAddr#, - plusAddr#, - minusAddr#, - remAddr#, - addr2Int#, - int2Addr#, - gtAddr#, - geAddr#, - eqAddr#, - neAddr#, - ltAddr#, - leAddr#, - indexCharOffAddr#, - indexWideCharOffAddr#, - indexIntOffAddr#, - indexWordOffAddr#, - indexAddrOffAddr#, - indexFloatOffAddr#, - indexDoubleOffAddr#, - indexStablePtrOffAddr#, - indexInt8OffAddr#, - indexInt16OffAddr#, - indexInt32OffAddr#, - indexInt64OffAddr#, - indexWord8OffAddr#, - indexWord16OffAddr#, - indexWord32OffAddr#, - indexWord64OffAddr#, - readCharOffAddr#, - readWideCharOffAddr#, - readIntOffAddr#, - readWordOffAddr#, - readAddrOffAddr#, - readFloatOffAddr#, - readDoubleOffAddr#, - readStablePtrOffAddr#, - readInt8OffAddr#, - readInt16OffAddr#, - readInt32OffAddr#, - readInt64OffAddr#, - readWord8OffAddr#, - readWord16OffAddr#, - readWord32OffAddr#, - readWord64OffAddr#, - writeCharOffAddr#, - writeWideCharOffAddr#, - writeIntOffAddr#, - writeWordOffAddr#, - writeAddrOffAddr#, - writeFloatOffAddr#, - writeDoubleOffAddr#, - writeStablePtrOffAddr#, - writeInt8OffAddr#, - writeInt16OffAddr#, - writeInt32OffAddr#, - writeInt64OffAddr#, - writeWord8OffAddr#, - writeWord16OffAddr#, - writeWord32OffAddr#, - writeWord64OffAddr#, - --- * Mutable variables --- |Operations on MutVar\#s. - - MutVar#, - newMutVar#, - readMutVar#, - writeMutVar#, - sameMutVar#, - atomicModifyMutVar2#, - atomicModifyMutVar_#, - casMutVar#, - --- * Exceptions --- | - - catch#, - raise#, - raiseIO#, - maskAsyncExceptions#, - maskUninterruptible#, - unmaskAsyncExceptions#, - getMaskingState#, - --- * STM-accessible Mutable Variables --- | - - TVar#, - atomically#, - retry#, - catchRetry#, - catchSTM#, - newTVar#, - readTVar#, - readTVarIO#, - writeTVar#, - sameTVar#, - --- * Synchronized Mutable Variables --- |Operations on @MVar\#@s. - - MVar#, - newMVar#, - takeMVar#, - tryTakeMVar#, - putMVar#, - tryPutMVar#, - readMVar#, - tryReadMVar#, - sameMVar#, - isEmptyMVar#, - --- * Delay\/wait operations --- | - - delay#, - waitRead#, - waitWrite#, - --- * Concurrency primitives --- | - - State#, - RealWorld, - ThreadId#, - fork#, - forkOn#, - killThread#, - yield#, - myThreadId#, - labelThread#, - isCurrentThreadBound#, - noDuplicate#, - threadStatus#, - --- * Weak pointers --- | - - Weak#, - mkWeak#, - mkWeakNoFinalizer#, - addCFinalizerToWeak#, - deRefWeak#, - finalizeWeak#, - touch#, - --- * Stable pointers and names --- | - - StablePtr#, - StableName#, - makeStablePtr#, - deRefStablePtr#, - eqStablePtr#, - makeStableName#, - eqStableName#, - stableNameToInt#, - --- * Compact normal form --- |Primitives for working with compact regions. The @ghc\-compact@ --- library and the @compact@ library demonstrate how to use these --- primitives. The documentation below draws a distinction between --- a CNF and a compact block. A CNF contains one or more compact --- blocks. The source file @rts\\/sm\\/CNF.c@ --- diagrams this relationship. When discussing a compact --- block, an additional distinction is drawn between capacity and --- utilized bytes. The capacity is the maximum number of bytes that --- the compact block can hold. The utilized bytes is the number of --- bytes that are actually used by the compact block. --- - - Compact#, - compactNew#, - compactResize#, - compactContains#, - compactContainsAny#, - compactGetFirstBlock#, - compactGetNextBlock#, - compactAllocateBlock#, - compactFixupPointers#, - compactAdd#, - compactAddWithSharing#, - compactSize#, - --- * Unsafe pointer equality --- | - - reallyUnsafePtrEquality#, - --- * Parallelism --- | - - par#, - spark#, - seq#, - getSpark#, - numSparks#, - --- * Tag to enum stuff --- |Convert back and forth between values of enumerated types --- and small integers. - - dataToTag#, - tagToEnum#, - --- * Bytecode operations --- |Support for manipulating bytecode objects used by the interpreter and --- linker. --- --- Bytecode objects are heap objects which represent top-level bindings and --- contain a list of instructions and data needed by these instructions. - - BCO#, - addrToAny#, - anyToAddr#, - mkApUpd0#, - newBCO#, - unpackClosure#, - closureSize#, - getApStackVal#, - --- * Misc --- |These aren\'t nearly as wired in as Etc... - - getCCSOf#, - getCurrentCCS#, - clearCCS#, - --- * Etc --- |Miscellaneous built-ins - - Proxy#, - proxy#, - seq, - unsafeCoerce#, - traceEvent#, - traceBinaryEvent#, - traceMarker#, - setThreadAllocationCounter#, - --- * Safe coercions --- | - - coerce, - --- * SIMD Vectors --- |Operations on SIMD vectors. - - Int8X16#, - Int16X8#, - Int32X4#, - Int64X2#, - Int8X32#, - Int16X16#, - Int32X8#, - Int64X4#, - Int8X64#, - Int16X32#, - Int32X16#, - Int64X8#, - Word8X16#, - Word16X8#, - Word32X4#, - Word64X2#, - Word8X32#, - Word16X16#, - Word32X8#, - Word64X4#, - Word8X64#, - Word16X32#, - Word32X16#, - Word64X8#, - FloatX4#, - DoubleX2#, - FloatX8#, - DoubleX4#, - FloatX16#, - DoubleX8#, - broadcastInt8X16#, - broadcastInt16X8#, - broadcastInt32X4#, - broadcastInt64X2#, - broadcastInt8X32#, - broadcastInt16X16#, - broadcastInt32X8#, - broadcastInt64X4#, - broadcastInt8X64#, - broadcastInt16X32#, - broadcastInt32X16#, - broadcastInt64X8#, - broadcastWord8X16#, - broadcastWord16X8#, - broadcastWord32X4#, - broadcastWord64X2#, - broadcastWord8X32#, - broadcastWord16X16#, - broadcastWord32X8#, - broadcastWord64X4#, - broadcastWord8X64#, - broadcastWord16X32#, - broadcastWord32X16#, - broadcastWord64X8#, - broadcastFloatX4#, - broadcastDoubleX2#, - broadcastFloatX8#, - broadcastDoubleX4#, - broadcastFloatX16#, - broadcastDoubleX8#, - packInt8X16#, - packInt16X8#, - packInt32X4#, - packInt64X2#, - packInt8X32#, - packInt16X16#, - packInt32X8#, - packInt64X4#, - packInt8X64#, - packInt16X32#, - packInt32X16#, - packInt64X8#, - packWord8X16#, - packWord16X8#, - packWord32X4#, - packWord64X2#, - packWord8X32#, - packWord16X16#, - packWord32X8#, - packWord64X4#, - packWord8X64#, - packWord16X32#, - packWord32X16#, - packWord64X8#, - packFloatX4#, - packDoubleX2#, - packFloatX8#, - packDoubleX4#, - packFloatX16#, - packDoubleX8#, - unpackInt8X16#, - unpackInt16X8#, - unpackInt32X4#, - unpackInt64X2#, - unpackInt8X32#, - unpackInt16X16#, - unpackInt32X8#, - unpackInt64X4#, - unpackInt8X64#, - unpackInt16X32#, - unpackInt32X16#, - unpackInt64X8#, - unpackWord8X16#, - unpackWord16X8#, - unpackWord32X4#, - unpackWord64X2#, - unpackWord8X32#, - unpackWord16X16#, - unpackWord32X8#, - unpackWord64X4#, - unpackWord8X64#, - unpackWord16X32#, - unpackWord32X16#, - unpackWord64X8#, - unpackFloatX4#, - unpackDoubleX2#, - unpackFloatX8#, - unpackDoubleX4#, - unpackFloatX16#, - unpackDoubleX8#, - insertInt8X16#, - insertInt16X8#, - insertInt32X4#, - insertInt64X2#, - insertInt8X32#, - insertInt16X16#, - insertInt32X8#, - insertInt64X4#, - insertInt8X64#, - insertInt16X32#, - insertInt32X16#, - insertInt64X8#, - insertWord8X16#, - insertWord16X8#, - insertWord32X4#, - insertWord64X2#, - insertWord8X32#, - insertWord16X16#, - insertWord32X8#, - insertWord64X4#, - insertWord8X64#, - insertWord16X32#, - insertWord32X16#, - insertWord64X8#, - insertFloatX4#, - insertDoubleX2#, - insertFloatX8#, - insertDoubleX4#, - insertFloatX16#, - insertDoubleX8#, - plusInt8X16#, - plusInt16X8#, - plusInt32X4#, - plusInt64X2#, - plusInt8X32#, - plusInt16X16#, - plusInt32X8#, - plusInt64X4#, - plusInt8X64#, - plusInt16X32#, - plusInt32X16#, - plusInt64X8#, - plusWord8X16#, - plusWord16X8#, - plusWord32X4#, - plusWord64X2#, - plusWord8X32#, - plusWord16X16#, - plusWord32X8#, - plusWord64X4#, - plusWord8X64#, - plusWord16X32#, - plusWord32X16#, - plusWord64X8#, - plusFloatX4#, - plusDoubleX2#, - plusFloatX8#, - plusDoubleX4#, - plusFloatX16#, - plusDoubleX8#, - minusInt8X16#, - minusInt16X8#, - minusInt32X4#, - minusInt64X2#, - minusInt8X32#, - minusInt16X16#, - minusInt32X8#, - minusInt64X4#, - minusInt8X64#, - minusInt16X32#, - minusInt32X16#, - minusInt64X8#, - minusWord8X16#, - minusWord16X8#, - minusWord32X4#, - minusWord64X2#, - minusWord8X32#, - minusWord16X16#, - minusWord32X8#, - minusWord64X4#, - minusWord8X64#, - minusWord16X32#, - minusWord32X16#, - minusWord64X8#, - minusFloatX4#, - minusDoubleX2#, - minusFloatX8#, - minusDoubleX4#, - minusFloatX16#, - minusDoubleX8#, - timesInt8X16#, - timesInt16X8#, - timesInt32X4#, - timesInt64X2#, - timesInt8X32#, - timesInt16X16#, - timesInt32X8#, - timesInt64X4#, - timesInt8X64#, - timesInt16X32#, - timesInt32X16#, - timesInt64X8#, - timesWord8X16#, - timesWord16X8#, - timesWord32X4#, - timesWord64X2#, - timesWord8X32#, - timesWord16X16#, - timesWord32X8#, - timesWord64X4#, - timesWord8X64#, - timesWord16X32#, - timesWord32X16#, - timesWord64X8#, - timesFloatX4#, - timesDoubleX2#, - timesFloatX8#, - timesDoubleX4#, - timesFloatX16#, - timesDoubleX8#, - divideFloatX4#, - divideDoubleX2#, - divideFloatX8#, - divideDoubleX4#, - divideFloatX16#, - divideDoubleX8#, - quotInt8X16#, - quotInt16X8#, - quotInt32X4#, - quotInt64X2#, - quotInt8X32#, - quotInt16X16#, - quotInt32X8#, - quotInt64X4#, - quotInt8X64#, - quotInt16X32#, - quotInt32X16#, - quotInt64X8#, - quotWord8X16#, - quotWord16X8#, - quotWord32X4#, - quotWord64X2#, - quotWord8X32#, - quotWord16X16#, - quotWord32X8#, - quotWord64X4#, - quotWord8X64#, - quotWord16X32#, - quotWord32X16#, - quotWord64X8#, - remInt8X16#, - remInt16X8#, - remInt32X4#, - remInt64X2#, - remInt8X32#, - remInt16X16#, - remInt32X8#, - remInt64X4#, - remInt8X64#, - remInt16X32#, - remInt32X16#, - remInt64X8#, - remWord8X16#, - remWord16X8#, - remWord32X4#, - remWord64X2#, - remWord8X32#, - remWord16X16#, - remWord32X8#, - remWord64X4#, - remWord8X64#, - remWord16X32#, - remWord32X16#, - remWord64X8#, - negateInt8X16#, - negateInt16X8#, - negateInt32X4#, - negateInt64X2#, - negateInt8X32#, - negateInt16X16#, - negateInt32X8#, - negateInt64X4#, - negateInt8X64#, - negateInt16X32#, - negateInt32X16#, - negateInt64X8#, - negateFloatX4#, - negateDoubleX2#, - negateFloatX8#, - negateDoubleX4#, - negateFloatX16#, - negateDoubleX8#, - indexInt8X16Array#, - indexInt16X8Array#, - indexInt32X4Array#, - indexInt64X2Array#, - indexInt8X32Array#, - indexInt16X16Array#, - indexInt32X8Array#, - indexInt64X4Array#, - indexInt8X64Array#, - indexInt16X32Array#, - indexInt32X16Array#, - indexInt64X8Array#, - indexWord8X16Array#, - indexWord16X8Array#, - indexWord32X4Array#, - indexWord64X2Array#, - indexWord8X32Array#, - indexWord16X16Array#, - indexWord32X8Array#, - indexWord64X4Array#, - indexWord8X64Array#, - indexWord16X32Array#, - indexWord32X16Array#, - indexWord64X8Array#, - indexFloatX4Array#, - indexDoubleX2Array#, - indexFloatX8Array#, - indexDoubleX4Array#, - indexFloatX16Array#, - indexDoubleX8Array#, - readInt8X16Array#, - readInt16X8Array#, - readInt32X4Array#, - readInt64X2Array#, - readInt8X32Array#, - readInt16X16Array#, - readInt32X8Array#, - readInt64X4Array#, - readInt8X64Array#, - readInt16X32Array#, - readInt32X16Array#, - readInt64X8Array#, - readWord8X16Array#, - readWord16X8Array#, - readWord32X4Array#, - readWord64X2Array#, - readWord8X32Array#, - readWord16X16Array#, - readWord32X8Array#, - readWord64X4Array#, - readWord8X64Array#, - readWord16X32Array#, - readWord32X16Array#, - readWord64X8Array#, - readFloatX4Array#, - readDoubleX2Array#, - readFloatX8Array#, - readDoubleX4Array#, - readFloatX16Array#, - readDoubleX8Array#, - writeInt8X16Array#, - writeInt16X8Array#, - writeInt32X4Array#, - writeInt64X2Array#, - writeInt8X32Array#, - writeInt16X16Array#, - writeInt32X8Array#, - writeInt64X4Array#, - writeInt8X64Array#, - writeInt16X32Array#, - writeInt32X16Array#, - writeInt64X8Array#, - writeWord8X16Array#, - writeWord16X8Array#, - writeWord32X4Array#, - writeWord64X2Array#, - writeWord8X32Array#, - writeWord16X16Array#, - writeWord32X8Array#, - writeWord64X4Array#, - writeWord8X64Array#, - writeWord16X32Array#, - writeWord32X16Array#, - writeWord64X8Array#, - writeFloatX4Array#, - writeDoubleX2Array#, - writeFloatX8Array#, - writeDoubleX4Array#, - writeFloatX16Array#, - writeDoubleX8Array#, - indexInt8X16OffAddr#, - indexInt16X8OffAddr#, - indexInt32X4OffAddr#, - indexInt64X2OffAddr#, - indexInt8X32OffAddr#, - indexInt16X16OffAddr#, - indexInt32X8OffAddr#, - indexInt64X4OffAddr#, - indexInt8X64OffAddr#, - indexInt16X32OffAddr#, - indexInt32X16OffAddr#, - indexInt64X8OffAddr#, - indexWord8X16OffAddr#, - indexWord16X8OffAddr#, - indexWord32X4OffAddr#, - indexWord64X2OffAddr#, - indexWord8X32OffAddr#, - indexWord16X16OffAddr#, - indexWord32X8OffAddr#, - indexWord64X4OffAddr#, - indexWord8X64OffAddr#, - indexWord16X32OffAddr#, - indexWord32X16OffAddr#, - indexWord64X8OffAddr#, - indexFloatX4OffAddr#, - indexDoubleX2OffAddr#, - indexFloatX8OffAddr#, - indexDoubleX4OffAddr#, - indexFloatX16OffAddr#, - indexDoubleX8OffAddr#, - readInt8X16OffAddr#, - readInt16X8OffAddr#, - readInt32X4OffAddr#, - readInt64X2OffAddr#, - readInt8X32OffAddr#, - readInt16X16OffAddr#, - readInt32X8OffAddr#, - readInt64X4OffAddr#, - readInt8X64OffAddr#, - readInt16X32OffAddr#, - readInt32X16OffAddr#, - readInt64X8OffAddr#, - readWord8X16OffAddr#, - readWord16X8OffAddr#, - readWord32X4OffAddr#, - readWord64X2OffAddr#, - readWord8X32OffAddr#, - readWord16X16OffAddr#, - readWord32X8OffAddr#, - readWord64X4OffAddr#, - readWord8X64OffAddr#, - readWord16X32OffAddr#, - readWord32X16OffAddr#, - readWord64X8OffAddr#, - readFloatX4OffAddr#, - readDoubleX2OffAddr#, - readFloatX8OffAddr#, - readDoubleX4OffAddr#, - readFloatX16OffAddr#, - readDoubleX8OffAddr#, - writeInt8X16OffAddr#, - writeInt16X8OffAddr#, - writeInt32X4OffAddr#, - writeInt64X2OffAddr#, - writeInt8X32OffAddr#, - writeInt16X16OffAddr#, - writeInt32X8OffAddr#, - writeInt64X4OffAddr#, - writeInt8X64OffAddr#, - writeInt16X32OffAddr#, - writeInt32X16OffAddr#, - writeInt64X8OffAddr#, - writeWord8X16OffAddr#, - writeWord16X8OffAddr#, - writeWord32X4OffAddr#, - writeWord64X2OffAddr#, - writeWord8X32OffAddr#, - writeWord16X16OffAddr#, - writeWord32X8OffAddr#, - writeWord64X4OffAddr#, - writeWord8X64OffAddr#, - writeWord16X32OffAddr#, - writeWord32X16OffAddr#, - writeWord64X8OffAddr#, - writeFloatX4OffAddr#, - writeDoubleX2OffAddr#, - writeFloatX8OffAddr#, - writeDoubleX4OffAddr#, - writeFloatX16OffAddr#, - writeDoubleX8OffAddr#, - indexInt8ArrayAsInt8X16#, - indexInt16ArrayAsInt16X8#, - indexInt32ArrayAsInt32X4#, - indexInt64ArrayAsInt64X2#, - indexInt8ArrayAsInt8X32#, - indexInt16ArrayAsInt16X16#, - indexInt32ArrayAsInt32X8#, - indexInt64ArrayAsInt64X4#, - indexInt8ArrayAsInt8X64#, - indexInt16ArrayAsInt16X32#, - indexInt32ArrayAsInt32X16#, - indexInt64ArrayAsInt64X8#, - indexWord8ArrayAsWord8X16#, - indexWord16ArrayAsWord16X8#, - indexWord32ArrayAsWord32X4#, - indexWord64ArrayAsWord64X2#, - indexWord8ArrayAsWord8X32#, - indexWord16ArrayAsWord16X16#, - indexWord32ArrayAsWord32X8#, - indexWord64ArrayAsWord64X4#, - indexWord8ArrayAsWord8X64#, - indexWord16ArrayAsWord16X32#, - indexWord32ArrayAsWord32X16#, - indexWord64ArrayAsWord64X8#, - indexFloatArrayAsFloatX4#, - indexDoubleArrayAsDoubleX2#, - indexFloatArrayAsFloatX8#, - indexDoubleArrayAsDoubleX4#, - indexFloatArrayAsFloatX16#, - indexDoubleArrayAsDoubleX8#, - readInt8ArrayAsInt8X16#, - readInt16ArrayAsInt16X8#, - readInt32ArrayAsInt32X4#, - readInt64ArrayAsInt64X2#, - readInt8ArrayAsInt8X32#, - readInt16ArrayAsInt16X16#, - readInt32ArrayAsInt32X8#, - readInt64ArrayAsInt64X4#, - readInt8ArrayAsInt8X64#, - readInt16ArrayAsInt16X32#, - readInt32ArrayAsInt32X16#, - readInt64ArrayAsInt64X8#, - readWord8ArrayAsWord8X16#, - readWord16ArrayAsWord16X8#, - readWord32ArrayAsWord32X4#, - readWord64ArrayAsWord64X2#, - readWord8ArrayAsWord8X32#, - readWord16ArrayAsWord16X16#, - readWord32ArrayAsWord32X8#, - readWord64ArrayAsWord64X4#, - readWord8ArrayAsWord8X64#, - readWord16ArrayAsWord16X32#, - readWord32ArrayAsWord32X16#, - readWord64ArrayAsWord64X8#, - readFloatArrayAsFloatX4#, - readDoubleArrayAsDoubleX2#, - readFloatArrayAsFloatX8#, - readDoubleArrayAsDoubleX4#, - readFloatArrayAsFloatX16#, - readDoubleArrayAsDoubleX8#, - writeInt8ArrayAsInt8X16#, - writeInt16ArrayAsInt16X8#, - writeInt32ArrayAsInt32X4#, - writeInt64ArrayAsInt64X2#, - writeInt8ArrayAsInt8X32#, - writeInt16ArrayAsInt16X16#, - writeInt32ArrayAsInt32X8#, - writeInt64ArrayAsInt64X4#, - writeInt8ArrayAsInt8X64#, - writeInt16ArrayAsInt16X32#, - writeInt32ArrayAsInt32X16#, - writeInt64ArrayAsInt64X8#, - writeWord8ArrayAsWord8X16#, - writeWord16ArrayAsWord16X8#, - writeWord32ArrayAsWord32X4#, - writeWord64ArrayAsWord64X2#, - writeWord8ArrayAsWord8X32#, - writeWord16ArrayAsWord16X16#, - writeWord32ArrayAsWord32X8#, - writeWord64ArrayAsWord64X4#, - writeWord8ArrayAsWord8X64#, - writeWord16ArrayAsWord16X32#, - writeWord32ArrayAsWord32X16#, - writeWord64ArrayAsWord64X8#, - writeFloatArrayAsFloatX4#, - writeDoubleArrayAsDoubleX2#, - writeFloatArrayAsFloatX8#, - writeDoubleArrayAsDoubleX4#, - writeFloatArrayAsFloatX16#, - writeDoubleArrayAsDoubleX8#, - indexInt8OffAddrAsInt8X16#, - indexInt16OffAddrAsInt16X8#, - indexInt32OffAddrAsInt32X4#, - indexInt64OffAddrAsInt64X2#, - indexInt8OffAddrAsInt8X32#, - indexInt16OffAddrAsInt16X16#, - indexInt32OffAddrAsInt32X8#, - indexInt64OffAddrAsInt64X4#, - indexInt8OffAddrAsInt8X64#, - indexInt16OffAddrAsInt16X32#, - indexInt32OffAddrAsInt32X16#, - indexInt64OffAddrAsInt64X8#, - indexWord8OffAddrAsWord8X16#, - indexWord16OffAddrAsWord16X8#, - indexWord32OffAddrAsWord32X4#, - indexWord64OffAddrAsWord64X2#, - indexWord8OffAddrAsWord8X32#, - indexWord16OffAddrAsWord16X16#, - indexWord32OffAddrAsWord32X8#, - indexWord64OffAddrAsWord64X4#, - indexWord8OffAddrAsWord8X64#, - indexWord16OffAddrAsWord16X32#, - indexWord32OffAddrAsWord32X16#, - indexWord64OffAddrAsWord64X8#, - indexFloatOffAddrAsFloatX4#, - indexDoubleOffAddrAsDoubleX2#, - indexFloatOffAddrAsFloatX8#, - indexDoubleOffAddrAsDoubleX4#, - indexFloatOffAddrAsFloatX16#, - indexDoubleOffAddrAsDoubleX8#, - readInt8OffAddrAsInt8X16#, - readInt16OffAddrAsInt16X8#, - readInt32OffAddrAsInt32X4#, - readInt64OffAddrAsInt64X2#, - readInt8OffAddrAsInt8X32#, - readInt16OffAddrAsInt16X16#, - readInt32OffAddrAsInt32X8#, - readInt64OffAddrAsInt64X4#, - readInt8OffAddrAsInt8X64#, - readInt16OffAddrAsInt16X32#, - readInt32OffAddrAsInt32X16#, - readInt64OffAddrAsInt64X8#, - readWord8OffAddrAsWord8X16#, - readWord16OffAddrAsWord16X8#, - readWord32OffAddrAsWord32X4#, - readWord64OffAddrAsWord64X2#, - readWord8OffAddrAsWord8X32#, - readWord16OffAddrAsWord16X16#, - readWord32OffAddrAsWord32X8#, - readWord64OffAddrAsWord64X4#, - readWord8OffAddrAsWord8X64#, - readWord16OffAddrAsWord16X32#, - readWord32OffAddrAsWord32X16#, - readWord64OffAddrAsWord64X8#, - readFloatOffAddrAsFloatX4#, - readDoubleOffAddrAsDoubleX2#, - readFloatOffAddrAsFloatX8#, - readDoubleOffAddrAsDoubleX4#, - readFloatOffAddrAsFloatX16#, - readDoubleOffAddrAsDoubleX8#, - writeInt8OffAddrAsInt8X16#, - writeInt16OffAddrAsInt16X8#, - writeInt32OffAddrAsInt32X4#, - writeInt64OffAddrAsInt64X2#, - writeInt8OffAddrAsInt8X32#, - writeInt16OffAddrAsInt16X16#, - writeInt32OffAddrAsInt32X8#, - writeInt64OffAddrAsInt64X4#, - writeInt8OffAddrAsInt8X64#, - writeInt16OffAddrAsInt16X32#, - writeInt32OffAddrAsInt32X16#, - writeInt64OffAddrAsInt64X8#, - writeWord8OffAddrAsWord8X16#, - writeWord16OffAddrAsWord16X8#, - writeWord32OffAddrAsWord32X4#, - writeWord64OffAddrAsWord64X2#, - writeWord8OffAddrAsWord8X32#, - writeWord16OffAddrAsWord16X16#, - writeWord32OffAddrAsWord32X8#, - writeWord64OffAddrAsWord64X4#, - writeWord8OffAddrAsWord8X64#, - writeWord16OffAddrAsWord16X32#, - writeWord32OffAddrAsWord32X16#, - writeWord64OffAddrAsWord64X8#, - writeFloatOffAddrAsFloatX4#, - writeDoubleOffAddrAsDoubleX2#, - writeFloatOffAddrAsFloatX8#, - writeDoubleOffAddrAsDoubleX4#, - writeFloatOffAddrAsFloatX16#, - writeDoubleOffAddrAsDoubleX8#, - --- * Prefetch --- |Prefetch operations: Note how every prefetch operation has a name --- with the pattern prefetch*N#, where N is either 0,1,2, or 3. --- --- This suffix number, N, is the \"locality level\" of the prefetch, following the --- convention in GCC and other compilers. --- Higher locality numbers correspond to the memory being loaded in more --- levels of the cpu cache, and being retained after initial use. The naming --- convention follows the naming convention of the prefetch intrinsic found --- in the GCC and Clang C compilers. --- --- On the LLVM backend, prefetch*N# uses the LLVM prefetch intrinsic --- with locality level N. The code generated by LLVM is target architecture --- dependent, but should agree with the GHC NCG on x86 systems. --- --- On the Sparc and PPC native backends, prefetch*N is a No-Op. --- --- On the x86 NCG, N=0 will generate prefetchNTA, --- N=1 generates prefetcht2, N=2 generates prefetcht1, and --- N=3 generates prefetcht0. --- --- For streaming workloads, the prefetch*0 operations are recommended. --- For workloads which do many reads or writes to a memory location in a short period of time, --- prefetch*3 operations are recommended. --- --- For further reading about prefetch and associated systems performance optimization, --- the instruction set and optimization manuals by Intel and other CPU vendors are --- excellent starting place. --- --- --- The \"Intel 64 and IA-32 Architectures Optimization Reference Manual\" is --- especially a helpful read, even if your software is meant for other CPU --- architectures or vendor hardware. The manual can be found at --- http:\/\/www.intel.com\/content\/www\/us\/en\/architecture-and-technology\/64-ia-32-architectures-optimization-manual.html . --- --- The @prefetch*@ family of operations has the order of operations --- determined by passing around the @State#@ token. --- --- To get a \"pure\" version of these operations, use @inlinePerformIO@ which is quite safe in this context. --- --- It is important to note that while the prefetch operations will never change the --- answer to a pure computation, They CAN change the memory locations resident --- in a CPU cache and that may change the performance and timing characteristics --- of an application. The prefetch operations are marked has_side_effects=True --- to reflect that these operations have side effects with respect to the runtime --- performance characteristics of the resulting code. Additionally, if the prefetchValue --- operations did not have this attribute, GHC does a float out transformation that --- results in a let\/app violation, at least with the current design. --- - - prefetchByteArray3#, - prefetchMutableByteArray3#, - prefetchAddr3#, - prefetchValue3#, - prefetchByteArray2#, - prefetchMutableByteArray2#, - prefetchAddr2#, - prefetchValue2#, - prefetchByteArray1#, - prefetchMutableByteArray1#, - prefetchAddr1#, - prefetchValue1#, - prefetchByteArray0#, - prefetchMutableByteArray0#, - prefetchAddr0#, - prefetchValue0#, -) where - -{- -has_side_effects = False -out_of_line = False -can_fail = False -commutable = False -code_size = { primOpCodeSizeDefault } -strictness = { \ arity -> mkClosedStrictSig (replicate arity topDmd) topRes } -fixity = Nothing -llvm_only = False - -deprecated_msg = { } --} -import GHC.Types (Coercible) -default () - --- |The builtin function type, written in infix form as @a -> b@ and --- in prefix form as @(->) a b@. Values of this type are functions --- taking inputs of type @a@ and producing outputs of type @b@. --- --- Note that @a -> b@ permits levity-polymorphism in both @a@ and --- @b@, so that types like @Int\# -> Int\#@ can still be well-kinded. --- -infixr -1 -> -data (->) a b - -data Char# - -gtChar# :: Char# -> Char# -> Int# -gtChar# = gtChar# - -geChar# :: Char# -> Char# -> Int# -geChar# = geChar# - -eqChar# :: Char# -> Char# -> Int# -eqChar# = eqChar# - -neChar# :: Char# -> Char# -> Int# -neChar# = neChar# - -ltChar# :: Char# -> Char# -> Int# -ltChar# = ltChar# - -leChar# :: Char# -> Char# -> Int# -leChar# = leChar# - -ord# :: Char# -> Int# -ord# = ord# - -data Int# - -infixl 6 +# -(+#) :: Int# -> Int# -> Int# -(+#) = (+#) - -infixl 6 -# -(-#) :: Int# -> Int# -> Int# -(-#) = (-#) - --- |Low word of signed integer multiply. -infixl 7 *# -(*#) :: Int# -> Int# -> Int# -(*#) = (*#) - --- |Return non-zero if there is any possibility that the upper word of a --- signed integer multiply might contain useful information. Return --- zero only if you are completely sure that no overflow can occur. --- On a 32-bit platform, the recommended implementation is to do a --- 32 x 32 -> 64 signed multiply, and subtract result[63:32] from --- (result[31] >>signed 31). If this is zero, meaning that the --- upper word is merely a sign extension of the lower one, no --- overflow can occur. --- --- On a 64-bit platform it is not always possible to --- acquire the top 64 bits of the result. Therefore, a recommended --- implementation is to take the absolute value of both operands, and --- return 0 iff bits[63:31] of them are zero, since that means that their --- magnitudes fit within 31 bits, so the magnitude of the product must fit --- into 62 bits. --- --- If in doubt, return non-zero, but do make an effort to create the --- correct answer for small args, since otherwise the performance of --- @(*) :: Integer -> Integer -> Integer@ will be poor. --- -mulIntMayOflo# :: Int# -> Int# -> Int# -mulIntMayOflo# = mulIntMayOflo# - --- |Rounds towards zero. The behavior is undefined if the second argument is --- zero. --- --- --- __/Warning:/__ this can fail with an unchecked exception. -quotInt# :: Int# -> Int# -> Int# -quotInt# = quotInt# - --- |Satisfies @(quotInt\# x y) *\# y +\# (remInt\# x y) == x@. The --- behavior is undefined if the second argument is zero. --- --- --- __/Warning:/__ this can fail with an unchecked exception. -remInt# :: Int# -> Int# -> Int# -remInt# = remInt# - --- |Rounds towards zero. --- --- __/Warning:/__ this can fail with an unchecked exception. -quotRemInt# :: Int# -> Int# -> (# Int#,Int# #) -quotRemInt# = quotRemInt# - --- |Bitwise \"and\". -andI# :: Int# -> Int# -> Int# -andI# = andI# - --- |Bitwise \"or\". -orI# :: Int# -> Int# -> Int# -orI# = orI# - --- |Bitwise \"xor\". -xorI# :: Int# -> Int# -> Int# -xorI# = xorI# - --- |Bitwise \"not\", also known as the binary complement. -notI# :: Int# -> Int# -notI# = notI# - --- |Unary negation. --- Since the negative @Int#@ range extends one further than the --- positive range, @negateInt#@ of the most negative number is an --- identity operation. This way, @negateInt#@ is always its own inverse. -negateInt# :: Int# -> Int# -negateInt# = negateInt# - --- |Add signed integers reporting overflow. --- First member of result is the sum truncated to an @Int#@; --- second member is zero if the true sum fits in an @Int#@, --- nonzero if overflow occurred (the sum is either too large --- or too small to fit in an @Int#@). -addIntC# :: Int# -> Int# -> (# Int#,Int# #) -addIntC# = addIntC# - --- |Subtract signed integers reporting overflow. --- First member of result is the difference truncated to an @Int#@; --- second member is zero if the true difference fits in an @Int#@, --- nonzero if overflow occurred (the difference is either too large --- or too small to fit in an @Int#@). -subIntC# :: Int# -> Int# -> (# Int#,Int# #) -subIntC# = subIntC# - -infix 4 ># -(>#) :: Int# -> Int# -> Int# -(>#) = (>#) - -infix 4 >=# -(>=#) :: Int# -> Int# -> Int# -(>=#) = (>=#) - -infix 4 ==# -(==#) :: Int# -> Int# -> Int# -(==#) = (==#) - -infix 4 /=# -(/=#) :: Int# -> Int# -> Int# -(/=#) = (/=#) - -infix 4 <# -(<#) :: Int# -> Int# -> Int# -(<#) = (<#) - -infix 4 <=# -(<=#) :: Int# -> Int# -> Int# -(<=#) = (<=#) - -chr# :: Int# -> Char# -chr# = chr# - -int2Word# :: Int# -> Word# -int2Word# = int2Word# - -int2Float# :: Int# -> Float# -int2Float# = int2Float# - -int2Double# :: Int# -> Double# -int2Double# = int2Double# - -word2Float# :: Word# -> Float# -word2Float# = word2Float# - -word2Double# :: Word# -> Double# -word2Double# = word2Double# - --- |Shift left. Result undefined if shift amount is not --- in the range 0 to word size - 1 inclusive. -uncheckedIShiftL# :: Int# -> Int# -> Int# -uncheckedIShiftL# = uncheckedIShiftL# - --- |Shift right arithmetic. Result undefined if shift amount is not --- in the range 0 to word size - 1 inclusive. -uncheckedIShiftRA# :: Int# -> Int# -> Int# -uncheckedIShiftRA# = uncheckedIShiftRA# - --- |Shift right logical. Result undefined if shift amount is not --- in the range 0 to word size - 1 inclusive. -uncheckedIShiftRL# :: Int# -> Int# -> Int# -uncheckedIShiftRL# = uncheckedIShiftRL# - -data Int8# - -extendInt8# :: Int8# -> Int# -extendInt8# = extendInt8# - -narrowInt8# :: Int# -> Int8# -narrowInt8# = narrowInt8# - -negateInt8# :: Int8# -> Int8# -negateInt8# = negateInt8# - -plusInt8# :: Int8# -> Int8# -> Int8# -plusInt8# = plusInt8# - -subInt8# :: Int8# -> Int8# -> Int8# -subInt8# = subInt8# - -timesInt8# :: Int8# -> Int8# -> Int8# -timesInt8# = timesInt8# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -quotInt8# :: Int8# -> Int8# -> Int8# -quotInt8# = quotInt8# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -remInt8# :: Int8# -> Int8# -> Int8# -remInt8# = remInt8# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -quotRemInt8# :: Int8# -> Int8# -> (# Int8#,Int8# #) -quotRemInt8# = quotRemInt8# - -eqInt8# :: Int8# -> Int8# -> Int# -eqInt8# = eqInt8# - -geInt8# :: Int8# -> Int8# -> Int# -geInt8# = geInt8# - -gtInt8# :: Int8# -> Int8# -> Int# -gtInt8# = gtInt8# - -leInt8# :: Int8# -> Int8# -> Int# -leInt8# = leInt8# - -ltInt8# :: Int8# -> Int8# -> Int# -ltInt8# = ltInt8# - -neInt8# :: Int8# -> Int8# -> Int# -neInt8# = neInt8# - -data Word8# - -extendWord8# :: Word8# -> Word# -extendWord8# = extendWord8# - -narrowWord8# :: Word# -> Word8# -narrowWord8# = narrowWord8# - -notWord8# :: Word8# -> Word8# -notWord8# = notWord8# - -plusWord8# :: Word8# -> Word8# -> Word8# -plusWord8# = plusWord8# - -subWord8# :: Word8# -> Word8# -> Word8# -subWord8# = subWord8# - -timesWord8# :: Word8# -> Word8# -> Word8# -timesWord8# = timesWord8# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -quotWord8# :: Word8# -> Word8# -> Word8# -quotWord8# = quotWord8# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -remWord8# :: Word8# -> Word8# -> Word8# -remWord8# = remWord8# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -quotRemWord8# :: Word8# -> Word8# -> (# Word8#,Word8# #) -quotRemWord8# = quotRemWord8# - -eqWord8# :: Word8# -> Word8# -> Int# -eqWord8# = eqWord8# - -geWord8# :: Word8# -> Word8# -> Int# -geWord8# = geWord8# - -gtWord8# :: Word8# -> Word8# -> Int# -gtWord8# = gtWord8# - -leWord8# :: Word8# -> Word8# -> Int# -leWord8# = leWord8# - -ltWord8# :: Word8# -> Word8# -> Int# -ltWord8# = ltWord8# - -neWord8# :: Word8# -> Word8# -> Int# -neWord8# = neWord8# - -data Int16# - -extendInt16# :: Int16# -> Int# -extendInt16# = extendInt16# - -narrowInt16# :: Int# -> Int16# -narrowInt16# = narrowInt16# - -negateInt16# :: Int16# -> Int16# -negateInt16# = negateInt16# - -plusInt16# :: Int16# -> Int16# -> Int16# -plusInt16# = plusInt16# - -subInt16# :: Int16# -> Int16# -> Int16# -subInt16# = subInt16# - -timesInt16# :: Int16# -> Int16# -> Int16# -timesInt16# = timesInt16# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -quotInt16# :: Int16# -> Int16# -> Int16# -quotInt16# = quotInt16# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -remInt16# :: Int16# -> Int16# -> Int16# -remInt16# = remInt16# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -quotRemInt16# :: Int16# -> Int16# -> (# Int16#,Int16# #) -quotRemInt16# = quotRemInt16# - -eqInt16# :: Int16# -> Int16# -> Int# -eqInt16# = eqInt16# - -geInt16# :: Int16# -> Int16# -> Int# -geInt16# = geInt16# - -gtInt16# :: Int16# -> Int16# -> Int# -gtInt16# = gtInt16# - -leInt16# :: Int16# -> Int16# -> Int# -leInt16# = leInt16# - -ltInt16# :: Int16# -> Int16# -> Int# -ltInt16# = ltInt16# - -neInt16# :: Int16# -> Int16# -> Int# -neInt16# = neInt16# - -data Word16# - -extendWord16# :: Word16# -> Word# -extendWord16# = extendWord16# - -narrowWord16# :: Word# -> Word16# -narrowWord16# = narrowWord16# - -notWord16# :: Word16# -> Word16# -notWord16# = notWord16# - -plusWord16# :: Word16# -> Word16# -> Word16# -plusWord16# = plusWord16# - -subWord16# :: Word16# -> Word16# -> Word16# -subWord16# = subWord16# - -timesWord16# :: Word16# -> Word16# -> Word16# -timesWord16# = timesWord16# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -quotWord16# :: Word16# -> Word16# -> Word16# -quotWord16# = quotWord16# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -remWord16# :: Word16# -> Word16# -> Word16# -remWord16# = remWord16# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -quotRemWord16# :: Word16# -> Word16# -> (# Word16#,Word16# #) -quotRemWord16# = quotRemWord16# - -eqWord16# :: Word16# -> Word16# -> Int# -eqWord16# = eqWord16# - -geWord16# :: Word16# -> Word16# -> Int# -geWord16# = geWord16# - -gtWord16# :: Word16# -> Word16# -> Int# -gtWord16# = gtWord16# - -leWord16# :: Word16# -> Word16# -> Int# -leWord16# = leWord16# - -ltWord16# :: Word16# -> Word16# -> Int# -ltWord16# = ltWord16# - -neWord16# :: Word16# -> Word16# -> Int# -neWord16# = neWord16# - -data Word# - -plusWord# :: Word# -> Word# -> Word# -plusWord# = plusWord# - --- |Add unsigned integers reporting overflow. --- The first element of the pair is the result. The second element is --- the carry flag, which is nonzero on overflow. See also @plusWord2#@. -addWordC# :: Word# -> Word# -> (# Word#,Int# #) -addWordC# = addWordC# - --- |Subtract unsigned integers reporting overflow. --- The first element of the pair is the result. The second element is --- the carry flag, which is nonzero on overflow. -subWordC# :: Word# -> Word# -> (# Word#,Int# #) -subWordC# = subWordC# - --- |Add unsigned integers, with the high part (carry) in the first --- component of the returned pair and the low part in the second --- component of the pair. See also @addWordC#@. -plusWord2# :: Word# -> Word# -> (# Word#,Word# #) -plusWord2# = plusWord2# - -minusWord# :: Word# -> Word# -> Word# -minusWord# = minusWord# - -timesWord# :: Word# -> Word# -> Word# -timesWord# = timesWord# - -timesWord2# :: Word# -> Word# -> (# Word#,Word# #) -timesWord2# = timesWord2# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -quotWord# :: Word# -> Word# -> Word# -quotWord# = quotWord# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -remWord# :: Word# -> Word# -> Word# -remWord# = remWord# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -quotRemWord# :: Word# -> Word# -> (# Word#,Word# #) -quotRemWord# = quotRemWord# - --- | Takes high word of dividend, then low word of dividend, then divisor. --- Requires that high word \< divisor. --- --- __/Warning:/__ this can fail with an unchecked exception. -quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #) -quotRemWord2# = quotRemWord2# - -and# :: Word# -> Word# -> Word# -and# = and# - -or# :: Word# -> Word# -> Word# -or# = or# - -xor# :: Word# -> Word# -> Word# -xor# = xor# - -not# :: Word# -> Word# -not# = not# - --- |Shift left logical. Result undefined if shift amount is not --- in the range 0 to word size - 1 inclusive. -uncheckedShiftL# :: Word# -> Int# -> Word# -uncheckedShiftL# = uncheckedShiftL# - --- |Shift right logical. Result undefined if shift amount is not --- in the range 0 to word size - 1 inclusive. -uncheckedShiftRL# :: Word# -> Int# -> Word# -uncheckedShiftRL# = uncheckedShiftRL# - -word2Int# :: Word# -> Int# -word2Int# = word2Int# - -gtWord# :: Word# -> Word# -> Int# -gtWord# = gtWord# - -geWord# :: Word# -> Word# -> Int# -geWord# = geWord# - -eqWord# :: Word# -> Word# -> Int# -eqWord# = eqWord# - -neWord# :: Word# -> Word# -> Int# -neWord# = neWord# - -ltWord# :: Word# -> Word# -> Int# -ltWord# = ltWord# - -leWord# :: Word# -> Word# -> Int# -leWord# = leWord# - --- |Count the number of set bits in the lower 8 bits of a word. -popCnt8# :: Word# -> Word# -popCnt8# = popCnt8# - --- |Count the number of set bits in the lower 16 bits of a word. -popCnt16# :: Word# -> Word# -popCnt16# = popCnt16# - --- |Count the number of set bits in the lower 32 bits of a word. -popCnt32# :: Word# -> Word# -popCnt32# = popCnt32# - --- |Count the number of set bits in a 64-bit word. -popCnt64# :: Word# -> Word# -popCnt64# = popCnt64# - --- |Count the number of set bits in a word. -popCnt# :: Word# -> Word# -popCnt# = popCnt# - --- |Deposit bits to lower 8 bits of a word at locations specified by a mask. -pdep8# :: Word# -> Word# -> Word# -pdep8# = pdep8# - --- |Deposit bits to lower 16 bits of a word at locations specified by a mask. -pdep16# :: Word# -> Word# -> Word# -pdep16# = pdep16# - --- |Deposit bits to lower 32 bits of a word at locations specified by a mask. -pdep32# :: Word# -> Word# -> Word# -pdep32# = pdep32# - --- |Deposit bits to a word at locations specified by a mask. -pdep64# :: Word# -> Word# -> Word# -pdep64# = pdep64# - --- |Deposit bits to a word at locations specified by a mask. -pdep# :: Word# -> Word# -> Word# -pdep# = pdep# - --- |Extract bits from lower 8 bits of a word at locations specified by a mask. -pext8# :: Word# -> Word# -> Word# -pext8# = pext8# - --- |Extract bits from lower 16 bits of a word at locations specified by a mask. -pext16# :: Word# -> Word# -> Word# -pext16# = pext16# - --- |Extract bits from lower 32 bits of a word at locations specified by a mask. -pext32# :: Word# -> Word# -> Word# -pext32# = pext32# - --- |Extract bits from a word at locations specified by a mask. -pext64# :: Word# -> Word# -> Word# -pext64# = pext64# - --- |Extract bits from a word at locations specified by a mask. -pext# :: Word# -> Word# -> Word# -pext# = pext# - --- |Count leading zeros in the lower 8 bits of a word. -clz8# :: Word# -> Word# -clz8# = clz8# - --- |Count leading zeros in the lower 16 bits of a word. -clz16# :: Word# -> Word# -clz16# = clz16# - --- |Count leading zeros in the lower 32 bits of a word. -clz32# :: Word# -> Word# -clz32# = clz32# - --- |Count leading zeros in a 64-bit word. -clz64# :: Word# -> Word# -clz64# = clz64# - --- |Count leading zeros in a word. -clz# :: Word# -> Word# -clz# = clz# - --- |Count trailing zeros in the lower 8 bits of a word. -ctz8# :: Word# -> Word# -ctz8# = ctz8# - --- |Count trailing zeros in the lower 16 bits of a word. -ctz16# :: Word# -> Word# -ctz16# = ctz16# - --- |Count trailing zeros in the lower 32 bits of a word. -ctz32# :: Word# -> Word# -ctz32# = ctz32# - --- |Count trailing zeros in a 64-bit word. -ctz64# :: Word# -> Word# -ctz64# = ctz64# - --- |Count trailing zeros in a word. -ctz# :: Word# -> Word# -ctz# = ctz# - --- |Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. -byteSwap16# :: Word# -> Word# -byteSwap16# = byteSwap16# - --- |Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. -byteSwap32# :: Word# -> Word# -byteSwap32# = byteSwap32# - --- |Swap bytes in a 64 bits of a word. -byteSwap64# :: Word# -> Word# -byteSwap64# = byteSwap64# - --- |Swap bytes in a word. -byteSwap# :: Word# -> Word# -byteSwap# = byteSwap# - --- |Reverse the order of the bits in a 8-bit word. -bitReverse8# :: Word# -> Word# -bitReverse8# = bitReverse8# - --- |Reverse the order of the bits in a 16-bit word. -bitReverse16# :: Word# -> Word# -bitReverse16# = bitReverse16# - --- |Reverse the order of the bits in a 32-bit word. -bitReverse32# :: Word# -> Word# -bitReverse32# = bitReverse32# - --- |Reverse the order of the bits in a 64-bit word. -bitReverse64# :: Word# -> Word# -bitReverse64# = bitReverse64# - --- |Reverse the order of the bits in a word. -bitReverse# :: Word# -> Word# -bitReverse# = bitReverse# - -narrow8Int# :: Int# -> Int# -narrow8Int# = narrow8Int# - -narrow16Int# :: Int# -> Int# -narrow16Int# = narrow16Int# - -narrow32Int# :: Int# -> Int# -narrow32Int# = narrow32Int# - -narrow8Word# :: Word# -> Word# -narrow8Word# = narrow8Word# - -narrow16Word# :: Word# -> Word# -narrow16Word# = narrow16Word# - -narrow32Word# :: Word# -> Word# -narrow32Word# = narrow32Word# - -data Double# - -infix 4 >## -(>##) :: Double# -> Double# -> Int# -(>##) = (>##) - -infix 4 >=## -(>=##) :: Double# -> Double# -> Int# -(>=##) = (>=##) - -infix 4 ==## -(==##) :: Double# -> Double# -> Int# -(==##) = (==##) - -infix 4 /=## -(/=##) :: Double# -> Double# -> Int# -(/=##) = (/=##) - -infix 4 <## -(<##) :: Double# -> Double# -> Int# -(<##) = (<##) - -infix 4 <=## -(<=##) :: Double# -> Double# -> Int# -(<=##) = (<=##) - -infixl 6 +## -(+##) :: Double# -> Double# -> Double# -(+##) = (+##) - -infixl 6 -## -(-##) :: Double# -> Double# -> Double# -(-##) = (-##) - -infixl 7 *## -(*##) :: Double# -> Double# -> Double# -(*##) = (*##) - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -infixl 7 /## -(/##) :: Double# -> Double# -> Double# -(/##) = (/##) - -negateDouble# :: Double# -> Double# -negateDouble# = negateDouble# - -fabsDouble# :: Double# -> Double# -fabsDouble# = fabsDouble# - --- |Truncates a @Double#@ value to the nearest @Int#@. --- Results are undefined if the truncation if truncation yields --- a value outside the range of @Int#@. -double2Int# :: Double# -> Int# -double2Int# = double2Int# - -double2Float# :: Double# -> Float# -double2Float# = double2Float# - -expDouble# :: Double# -> Double# -expDouble# = expDouble# - -expm1Double# :: Double# -> Double# -expm1Double# = expm1Double# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -logDouble# :: Double# -> Double# -logDouble# = logDouble# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -log1pDouble# :: Double# -> Double# -log1pDouble# = log1pDouble# - -sqrtDouble# :: Double# -> Double# -sqrtDouble# = sqrtDouble# - -sinDouble# :: Double# -> Double# -sinDouble# = sinDouble# - -cosDouble# :: Double# -> Double# -cosDouble# = cosDouble# - -tanDouble# :: Double# -> Double# -tanDouble# = tanDouble# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -asinDouble# :: Double# -> Double# -asinDouble# = asinDouble# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -acosDouble# :: Double# -> Double# -acosDouble# = acosDouble# - -atanDouble# :: Double# -> Double# -atanDouble# = atanDouble# - -sinhDouble# :: Double# -> Double# -sinhDouble# = sinhDouble# - -coshDouble# :: Double# -> Double# -coshDouble# = coshDouble# - -tanhDouble# :: Double# -> Double# -tanhDouble# = tanhDouble# - -asinhDouble# :: Double# -> Double# -asinhDouble# = asinhDouble# - -acoshDouble# :: Double# -> Double# -acoshDouble# = acoshDouble# - -atanhDouble# :: Double# -> Double# -atanhDouble# = atanhDouble# - --- |Exponentiation. -(**##) :: Double# -> Double# -> Double# -(**##) = (**##) - --- |Convert to integer. --- First component of the result is -1 or 1, indicating the sign of the --- mantissa. The next two are the high and low 32 bits of the mantissa --- respectively, and the last is the exponent. -decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #) -decodeDouble_2Int# = decodeDouble_2Int# - --- |Decode @Double\#@ into mantissa and base-2 exponent. -decodeDouble_Int64# :: Double# -> (# Int#,Int# #) -decodeDouble_Int64# = decodeDouble_Int64# - -data Float# - -gtFloat# :: Float# -> Float# -> Int# -gtFloat# = gtFloat# - -geFloat# :: Float# -> Float# -> Int# -geFloat# = geFloat# - -eqFloat# :: Float# -> Float# -> Int# -eqFloat# = eqFloat# - -neFloat# :: Float# -> Float# -> Int# -neFloat# = neFloat# - -ltFloat# :: Float# -> Float# -> Int# -ltFloat# = ltFloat# - -leFloat# :: Float# -> Float# -> Int# -leFloat# = leFloat# - -plusFloat# :: Float# -> Float# -> Float# -plusFloat# = plusFloat# - -minusFloat# :: Float# -> Float# -> Float# -minusFloat# = minusFloat# - -timesFloat# :: Float# -> Float# -> Float# -timesFloat# = timesFloat# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -divideFloat# :: Float# -> Float# -> Float# -divideFloat# = divideFloat# - -negateFloat# :: Float# -> Float# -negateFloat# = negateFloat# - -fabsFloat# :: Float# -> Float# -fabsFloat# = fabsFloat# - --- |Truncates a @Float#@ value to the nearest @Int#@. --- Results are undefined if the truncation if truncation yields --- a value outside the range of @Int#@. -float2Int# :: Float# -> Int# -float2Int# = float2Int# - -expFloat# :: Float# -> Float# -expFloat# = expFloat# - -expm1Float# :: Float# -> Float# -expm1Float# = expm1Float# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -logFloat# :: Float# -> Float# -logFloat# = logFloat# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -log1pFloat# :: Float# -> Float# -log1pFloat# = log1pFloat# - -sqrtFloat# :: Float# -> Float# -sqrtFloat# = sqrtFloat# - -sinFloat# :: Float# -> Float# -sinFloat# = sinFloat# - -cosFloat# :: Float# -> Float# -cosFloat# = cosFloat# - -tanFloat# :: Float# -> Float# -tanFloat# = tanFloat# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -asinFloat# :: Float# -> Float# -asinFloat# = asinFloat# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -acosFloat# :: Float# -> Float# -acosFloat# = acosFloat# - -atanFloat# :: Float# -> Float# -atanFloat# = atanFloat# - -sinhFloat# :: Float# -> Float# -sinhFloat# = sinhFloat# - -coshFloat# :: Float# -> Float# -coshFloat# = coshFloat# - -tanhFloat# :: Float# -> Float# -tanhFloat# = tanhFloat# - -asinhFloat# :: Float# -> Float# -asinhFloat# = asinhFloat# - -acoshFloat# :: Float# -> Float# -acoshFloat# = acoshFloat# - -atanhFloat# :: Float# -> Float# -atanhFloat# = atanhFloat# - -powerFloat# :: Float# -> Float# -> Float# -powerFloat# = powerFloat# - -float2Double# :: Float# -> Double# -float2Double# = float2Double# - --- |Convert to integers. --- First @Int\#@ in result is the mantissa; second is the exponent. -decodeFloat_Int# :: Float# -> (# Int#,Int# #) -decodeFloat_Int# = decodeFloat_Int# - -data Array# a - -data MutableArray# s a - --- |Create a new mutable array with the specified number of elements, --- in the specified state thread, --- with each element containing the specified initial value. -newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #) -newArray# = newArray# - -sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int# -sameMutableArray# = sameMutableArray# - --- |Read from specified index of mutable array. Result is not yet evaluated. --- --- __/Warning:/__ this can fail with an unchecked exception. -readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #) -readArray# = readArray# - --- |Write to specified index of mutable array. --- --- __/Warning:/__ this can fail with an unchecked exception. -writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s -writeArray# = writeArray# - --- |Return the number of elements in the array. -sizeofArray# :: Array# a -> Int# -sizeofArray# = sizeofArray# - --- |Return the number of elements in the array. -sizeofMutableArray# :: MutableArray# s a -> Int# -sizeofMutableArray# = sizeofMutableArray# - --- |Read from the specified index of an immutable array. The result is packaged --- into an unboxed unary tuple; the result itself is not yet --- evaluated. Pattern matching on the tuple forces the indexing of the --- array to happen but does not evaluate the element itself. Evaluating --- the thunk prevents additional thunks from building up on the --- heap. Avoiding these thunks, in turn, reduces references to the --- argument array, allowing it to be garbage collected more promptly. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexArray# :: Array# a -> Int# -> (# a #) -indexArray# = indexArray# - --- |Make a mutable array immutable, without copying. -unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #) -unsafeFreezeArray# = unsafeFreezeArray# - --- |Make an immutable array mutable, without copying. -unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #) -unsafeThawArray# = unsafeThawArray# - --- |Given a source array, an offset into the source array, a --- destination array, an offset into the destination array, and a --- number of elements to copy, copy the elements from the source array --- to the destination array. Both arrays must fully contain the --- specified ranges, but this is not checked. The two arrays must not --- be the same array in different states, but this is not checked --- either. --- --- __/Warning:/__ this can fail with an unchecked exception. -copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s -copyArray# = copyArray# - --- |Given a source array, an offset into the source array, a --- destination array, an offset into the destination array, and a --- number of elements to copy, copy the elements from the source array --- to the destination array. Both arrays must fully contain the --- specified ranges, but this is not checked. In the case where --- the source and destination are the same array the source and --- destination regions may overlap. --- --- __/Warning:/__ this can fail with an unchecked exception. -copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s -copyMutableArray# = copyMutableArray# - --- |Given a source array, an offset into the source array, and a number --- of elements to copy, create a new array with the elements from the --- source array. The provided array must fully contain the specified --- range, but this is not checked. --- --- __/Warning:/__ this can fail with an unchecked exception. -cloneArray# :: Array# a -> Int# -> Int# -> Array# a -cloneArray# = cloneArray# - --- |Given a source array, an offset into the source array, and a number --- of elements to copy, create a new array with the elements from the --- source array. The provided array must fully contain the specified --- range, but this is not checked. --- --- __/Warning:/__ this can fail with an unchecked exception. -cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #) -cloneMutableArray# = cloneMutableArray# - --- |Given a source array, an offset into the source array, and a number --- of elements to copy, create a new array with the elements from the --- source array. The provided array must fully contain the specified --- range, but this is not checked. --- --- __/Warning:/__ this can fail with an unchecked exception. -freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #) -freezeArray# = freezeArray# - --- |Given a source array, an offset into the source array, and a number --- of elements to copy, create a new array with the elements from the --- source array. The provided array must fully contain the specified --- range, but this is not checked. --- --- __/Warning:/__ this can fail with an unchecked exception. -thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #) -thawArray# = thawArray# - --- |Given an array, an offset, the expected old value, and --- the new value, perform an atomic compare and swap (i.e. write the new --- value if the current value and the old value are the same pointer). --- Returns 0 if the swap succeeds and 1 if it fails. Additionally, returns --- the element at the offset after the operation completes. This means that --- on a success the new value is returned, and on a failure the actual old --- value (not the expected one) is returned. Implies a full memory barrier. --- The use of a pointer equality on a lifted value makes this function harder --- to use correctly than @casIntArray\#@. All of the difficulties --- of using @reallyUnsafePtrEquality\#@ correctly apply to --- @casArray\#@ as well. --- -casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #) -casArray# = casArray# - -data SmallArray# a - -data SmallMutableArray# s a - --- |Create a new mutable array with the specified number of elements, --- in the specified state thread, --- with each element containing the specified initial value. -newSmallArray# :: Int# -> a -> State# s -> (# State# s,SmallMutableArray# s a #) -newSmallArray# = newSmallArray# - -sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int# -sameSmallMutableArray# = sameSmallMutableArray# - --- |Shrink mutable array to new specified size, in --- the specified state thread. The new size argument must be less than or --- equal to the current size as reported by @sizeofSmallMutableArray\#@. -shrinkSmallMutableArray# :: SmallMutableArray# s a -> Int# -> State# s -> State# s -shrinkSmallMutableArray# = shrinkSmallMutableArray# - --- |Read from specified index of mutable array. Result is not yet evaluated. --- --- __/Warning:/__ this can fail with an unchecked exception. -readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (# State# s,a #) -readSmallArray# = readSmallArray# - --- |Write to specified index of mutable array. --- --- __/Warning:/__ this can fail with an unchecked exception. -writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s -writeSmallArray# = writeSmallArray# - --- |Return the number of elements in the array. -sizeofSmallArray# :: SmallArray# a -> Int# -sizeofSmallArray# = sizeofSmallArray# - --- |Return the number of elements in the array. Note that this is deprecated --- as it is unsafe in the presence of resize operations on the --- same byte array. -{-# DEPRECATED sizeofSmallMutableArray# " Use 'getSizeofSmallMutableArray#' instead " #-} -sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int# -sizeofSmallMutableArray# = sizeofSmallMutableArray# - --- |Return the number of elements in the array. -getSizeofSmallMutableArray# :: SmallMutableArray# s a -> State# s -> (# State# s,Int# #) -getSizeofSmallMutableArray# = getSizeofSmallMutableArray# - --- |Read from specified index of immutable array. Result is packaged into --- an unboxed singleton; the result itself is not yet evaluated. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexSmallArray# :: SmallArray# a -> Int# -> (# a #) -indexSmallArray# = indexSmallArray# - --- |Make a mutable array immutable, without copying. -unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (# State# s,SmallArray# a #) -unsafeFreezeSmallArray# = unsafeFreezeSmallArray# - --- |Make an immutable array mutable, without copying. -unsafeThawSmallArray# :: SmallArray# a -> State# s -> (# State# s,SmallMutableArray# s a #) -unsafeThawSmallArray# = unsafeThawSmallArray# - --- |Given a source array, an offset into the source array, a --- destination array, an offset into the destination array, and a --- number of elements to copy, copy the elements from the source array --- to the destination array. Both arrays must fully contain the --- specified ranges, but this is not checked. The two arrays must not --- be the same array in different states, but this is not checked --- either. --- --- __/Warning:/__ this can fail with an unchecked exception. -copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s -copySmallArray# = copySmallArray# - --- |Given a source array, an offset into the source array, a --- destination array, an offset into the destination array, and a --- number of elements to copy, copy the elements from the source array --- to the destination array. The source and destination arrays can --- refer to the same array. Both arrays must fully contain the --- specified ranges, but this is not checked. --- The regions are allowed to overlap, although this is only possible when the same --- array is provided as both the source and the destination. --- --- __/Warning:/__ this can fail with an unchecked exception. -copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s -copySmallMutableArray# = copySmallMutableArray# - --- |Given a source array, an offset into the source array, and a number --- of elements to copy, create a new array with the elements from the --- source array. The provided array must fully contain the specified --- range, but this is not checked. --- --- __/Warning:/__ this can fail with an unchecked exception. -cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a -cloneSmallArray# = cloneSmallArray# - --- |Given a source array, an offset into the source array, and a number --- of elements to copy, create a new array with the elements from the --- source array. The provided array must fully contain the specified --- range, but this is not checked. --- --- __/Warning:/__ this can fail with an unchecked exception. -cloneSmallMutableArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #) -cloneSmallMutableArray# = cloneSmallMutableArray# - --- |Given a source array, an offset into the source array, and a number --- of elements to copy, create a new array with the elements from the --- source array. The provided array must fully contain the specified --- range, but this is not checked. --- --- __/Warning:/__ this can fail with an unchecked exception. -freezeSmallArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallArray# a #) -freezeSmallArray# = freezeSmallArray# - --- |Given a source array, an offset into the source array, and a number --- of elements to copy, create a new array with the elements from the --- source array. The provided array must fully contain the specified --- range, but this is not checked. --- --- __/Warning:/__ this can fail with an unchecked exception. -thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #) -thawSmallArray# = thawSmallArray# - --- |Unsafe, machine-level atomic compare and swap on an element within an array. --- See the documentation of @casArray\#@. -casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #) -casSmallArray# = casSmallArray# - -data ByteArray# - -data MutableByteArray# s - --- |Create a new mutable byte array of specified size (in bytes), in --- the specified state thread. -newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) -newByteArray# = newByteArray# - --- |Create a mutable byte array that the GC guarantees not to move. -newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) -newPinnedByteArray# = newPinnedByteArray# - --- |Create a mutable byte array, aligned by the specified amount, that the GC guarantees not to move. -newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #) -newAlignedPinnedByteArray# = newAlignedPinnedByteArray# - --- |Determine whether a @MutableByteArray\#@ is guaranteed not to move --- during GC. -isMutableByteArrayPinned# :: MutableByteArray# s -> Int# -isMutableByteArrayPinned# = isMutableByteArrayPinned# - --- |Determine whether a @ByteArray\#@ is guaranteed not to move during GC. -isByteArrayPinned# :: ByteArray# -> Int# -isByteArrayPinned# = isByteArrayPinned# - --- |Intended for use with pinned arrays; otherwise very unsafe! -byteArrayContents# :: ByteArray# -> Addr# -byteArrayContents# = byteArrayContents# - -sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int# -sameMutableByteArray# = sameMutableByteArray# - --- |Shrink mutable byte array to new specified size (in bytes), in --- the specified state thread. The new size argument must be less than or --- equal to the current size as reported by @sizeofMutableByteArray\#@. -shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s -shrinkMutableByteArray# = shrinkMutableByteArray# - --- |Resize (unpinned) mutable byte array to new specified size (in bytes). --- The returned @MutableByteArray\#@ is either the original --- @MutableByteArray\#@ resized in-place or, if not possible, a newly --- allocated (unpinned) @MutableByteArray\#@ (with the original content --- copied over). --- --- To avoid undefined behaviour, the original @MutableByteArray\#@ shall --- not be accessed anymore after a @resizeMutableByteArray\#@ has been --- performed. Moreover, no reference to the old one should be kept in order --- to allow garbage collection of the original @MutableByteArray\#@ in --- case a new @MutableByteArray\#@ had to be allocated. -resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #) -resizeMutableByteArray# = resizeMutableByteArray# - --- |Make a mutable byte array immutable, without copying. -unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #) -unsafeFreezeByteArray# = unsafeFreezeByteArray# - --- |Return the size of the array in bytes. -sizeofByteArray# :: ByteArray# -> Int# -sizeofByteArray# = sizeofByteArray# - --- |Return the size of the array in bytes. Note that this is deprecated as it is --- unsafe in the presence of resize operations on the same byte --- array. -{-# DEPRECATED sizeofMutableByteArray# " Use 'getSizeofMutableByteArray#' instead " #-} -sizeofMutableByteArray# :: MutableByteArray# s -> Int# -sizeofMutableByteArray# = sizeofMutableByteArray# - --- |Return the number of elements in the array. -getSizeofMutableByteArray# :: MutableByteArray# s -> State# s -> (# State# s,Int# #) -getSizeofMutableByteArray# = getSizeofMutableByteArray# - --- |Read 8-bit character; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexCharArray# :: ByteArray# -> Int# -> Char# -indexCharArray# = indexCharArray# - --- |Read 31-bit character; offset in 4-byte words. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWideCharArray# :: ByteArray# -> Int# -> Char# -indexWideCharArray# = indexWideCharArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexIntArray# :: ByteArray# -> Int# -> Int# -indexIntArray# = indexIntArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWordArray# :: ByteArray# -> Int# -> Word# -indexWordArray# = indexWordArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexAddrArray# :: ByteArray# -> Int# -> Addr# -indexAddrArray# = indexAddrArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexFloatArray# :: ByteArray# -> Int# -> Float# -indexFloatArray# = indexFloatArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexDoubleArray# :: ByteArray# -> Int# -> Double# -indexDoubleArray# = indexDoubleArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a -indexStablePtrArray# = indexStablePtrArray# - --- |Read 8-bit integer; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexInt8Array# :: ByteArray# -> Int# -> Int# -indexInt8Array# = indexInt8Array# - --- |Read 16-bit integer; offset in 16-bit words. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexInt16Array# :: ByteArray# -> Int# -> Int# -indexInt16Array# = indexInt16Array# - --- |Read 32-bit integer; offset in 32-bit words. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexInt32Array# :: ByteArray# -> Int# -> Int# -indexInt32Array# = indexInt32Array# - --- |Read 64-bit integer; offset in 64-bit words. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexInt64Array# :: ByteArray# -> Int# -> Int# -indexInt64Array# = indexInt64Array# - --- |Read 8-bit word; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8Array# :: ByteArray# -> Int# -> Word# -indexWord8Array# = indexWord8Array# - --- |Read 16-bit word; offset in 16-bit words. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord16Array# :: ByteArray# -> Int# -> Word# -indexWord16Array# = indexWord16Array# - --- |Read 32-bit word; offset in 32-bit words. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord32Array# :: ByteArray# -> Int# -> Word# -indexWord32Array# = indexWord32Array# - --- |Read 64-bit word; offset in 64-bit words. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord64Array# :: ByteArray# -> Int# -> Word# -indexWord64Array# = indexWord64Array# - --- |Read 8-bit character; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char# -indexWord8ArrayAsChar# = indexWord8ArrayAsChar# - --- |Read 31-bit character; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char# -indexWord8ArrayAsWideChar# = indexWord8ArrayAsWideChar# - --- |Read address; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr# -indexWord8ArrayAsAddr# = indexWord8ArrayAsAddr# - --- |Read float; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float# -indexWord8ArrayAsFloat# = indexWord8ArrayAsFloat# - --- |Read double; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double# -indexWord8ArrayAsDouble# = indexWord8ArrayAsDouble# - --- |Read stable pointer; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a -indexWord8ArrayAsStablePtr# = indexWord8ArrayAsStablePtr# - --- |Read 16-bit int; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int# -indexWord8ArrayAsInt16# = indexWord8ArrayAsInt16# - --- |Read 32-bit int; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int# -indexWord8ArrayAsInt32# = indexWord8ArrayAsInt32# - --- |Read 64-bit int; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int# -indexWord8ArrayAsInt64# = indexWord8ArrayAsInt64# - --- |Read int; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int# -indexWord8ArrayAsInt# = indexWord8ArrayAsInt# - --- |Read 16-bit word; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word# -indexWord8ArrayAsWord16# = indexWord8ArrayAsWord16# - --- |Read 32-bit word; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word# -indexWord8ArrayAsWord32# = indexWord8ArrayAsWord32# - --- |Read 64-bit word; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word# -indexWord8ArrayAsWord64# = indexWord8ArrayAsWord64# - --- |Read word; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word# -indexWord8ArrayAsWord# = indexWord8ArrayAsWord# - --- |Read 8-bit character; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) -readCharArray# = readCharArray# - --- |Read 31-bit character; offset in 4-byte words. --- --- __/Warning:/__ this can fail with an unchecked exception. -readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) -readWideCharArray# = readWideCharArray# - --- |Read integer; offset in machine words. --- --- __/Warning:/__ this can fail with an unchecked exception. -readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readIntArray# = readIntArray# - --- |Read word; offset in machine words. --- --- __/Warning:/__ this can fail with an unchecked exception. -readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWordArray# = readWordArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #) -readAddrArray# = readAddrArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #) -readFloatArray# = readFloatArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #) -readDoubleArray# = readDoubleArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #) -readStablePtrArray# = readStablePtrArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readInt8Array# = readInt8Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readInt16Array# = readInt16Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readInt32Array# = readInt32Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readInt64Array# = readInt64Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord8Array# = readWord8Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord16Array# = readWord16Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord32Array# = readWord32Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord64Array# = readWord64Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsChar# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) -readWord8ArrayAsChar# = readWord8ArrayAsChar# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsWideChar# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) -readWord8ArrayAsWideChar# = readWord8ArrayAsWideChar# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsAddr# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #) -readWord8ArrayAsAddr# = readWord8ArrayAsAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsFloat# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #) -readWord8ArrayAsFloat# = readWord8ArrayAsFloat# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsDouble# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #) -readWord8ArrayAsDouble# = readWord8ArrayAsDouble# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsStablePtr# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #) -readWord8ArrayAsStablePtr# = readWord8ArrayAsStablePtr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readWord8ArrayAsInt16# = readWord8ArrayAsInt16# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readWord8ArrayAsInt32# = readWord8ArrayAsInt32# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readWord8ArrayAsInt64# = readWord8ArrayAsInt64# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readWord8ArrayAsInt# = readWord8ArrayAsInt# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord8ArrayAsWord16# = readWord8ArrayAsWord16# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord8ArrayAsWord32# = readWord8ArrayAsWord32# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord8ArrayAsWord64# = readWord8ArrayAsWord64# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord8ArrayAsWord# = readWord8ArrayAsWord# - --- |Write 8-bit character; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s -writeCharArray# = writeCharArray# - --- |Write 31-bit character; offset in 4-byte words. --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s -writeWideCharArray# = writeWideCharArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeIntArray# = writeIntArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWordArray# = writeWordArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s -writeAddrArray# = writeAddrArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s -writeFloatArray# = writeFloatArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s -writeDoubleArray# = writeDoubleArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s -writeStablePtrArray# = writeStablePtrArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeInt8Array# = writeInt8Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeInt16Array# = writeInt16Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeInt32Array# = writeInt32Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeInt64Array# = writeInt64Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord8Array# = writeWord8Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord16Array# = writeWord16Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord32Array# = writeWord32Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord64Array# = writeWord64Array# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsChar# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s -writeWord8ArrayAsChar# = writeWord8ArrayAsChar# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsWideChar# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s -writeWord8ArrayAsWideChar# = writeWord8ArrayAsWideChar# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsAddr# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s -writeWord8ArrayAsAddr# = writeWord8ArrayAsAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsFloat# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s -writeWord8ArrayAsFloat# = writeWord8ArrayAsFloat# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsDouble# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s -writeWord8ArrayAsDouble# = writeWord8ArrayAsDouble# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsStablePtr# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s -writeWord8ArrayAsStablePtr# = writeWord8ArrayAsStablePtr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeWord8ArrayAsInt16# = writeWord8ArrayAsInt16# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeWord8ArrayAsInt32# = writeWord8ArrayAsInt32# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeWord8ArrayAsInt64# = writeWord8ArrayAsInt64# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeWord8ArrayAsInt# = writeWord8ArrayAsInt# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord8ArrayAsWord16# = writeWord8ArrayAsWord16# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord8ArrayAsWord32# = writeWord8ArrayAsWord32# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord8ArrayAsWord64# = writeWord8ArrayAsWord64# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord8ArrayAsWord# = writeWord8ArrayAsWord# - --- |@compareByteArrays# src1 src1_ofs src2 src2_ofs n@ compares --- @n@ bytes starting at offset @src1_ofs@ in the first --- @ByteArray#@ @src1@ to the range of @n@ bytes --- (i.e. same length) starting at offset @src2_ofs@ of the second --- @ByteArray#@ @src2@. Both arrays must fully contain the --- specified ranges, but this is not checked. Returns an @Int#@ --- less than, equal to, or greater than zero if the range is found, --- respectively, to be byte-wise lexicographically less than, to --- match, or be greater than the second range. --- --- __/Warning:/__ this can fail with an unchecked exception. -compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int# -compareByteArrays# = compareByteArrays# - --- |@copyByteArray# src src_ofs dst dst_ofs n@ copies the range --- starting at offset @src_ofs@ of length @n@ from the --- @ByteArray#@ @src@ to the @MutableByteArray#@ @dst@ --- starting at offset @dst_ofs@. Both arrays must fully contain --- the specified ranges, but this is not checked. The two arrays must --- not be the same array in different states, but this is not checked --- either. --- --- __/Warning:/__ this can fail with an unchecked exception. -copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -copyByteArray# = copyByteArray# - --- |Copy a range of the first MutableByteArray\# to the specified region in the second MutableByteArray\#. --- Both arrays must fully contain the specified ranges, but this is not checked. The regions are --- allowed to overlap, although this is only possible when the same array is provided --- as both the source and the destination. --- --- __/Warning:/__ this can fail with an unchecked exception. -copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -copyMutableByteArray# = copyMutableByteArray# - --- |Copy a range of the ByteArray\# to the memory range starting at the Addr\#. --- The ByteArray\# and the memory region at Addr\# must fully contain the --- specified ranges, but this is not checked. The Addr\# must not point into the --- ByteArray\# (e.g. if the ByteArray\# were pinned), but this is not checked --- either. --- --- __/Warning:/__ this can fail with an unchecked exception. -copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s -copyByteArrayToAddr# = copyByteArrayToAddr# - --- |Copy a range of the MutableByteArray\# to the memory range starting at the --- Addr\#. The MutableByteArray\# and the memory region at Addr\# must fully --- contain the specified ranges, but this is not checked. The Addr\# must not --- point into the MutableByteArray\# (e.g. if the MutableByteArray\# were --- pinned), but this is not checked either. --- --- __/Warning:/__ this can fail with an unchecked exception. -copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s -copyMutableByteArrayToAddr# = copyMutableByteArrayToAddr# - --- |Copy a memory range starting at the Addr\# to the specified range in the --- MutableByteArray\#. The memory region at Addr\# and the ByteArray\# must fully --- contain the specified ranges, but this is not checked. The Addr\# must not --- point into the MutableByteArray\# (e.g. if the MutableByteArray\# were pinned), --- but this is not checked either. --- --- __/Warning:/__ this can fail with an unchecked exception. -copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -copyAddrToByteArray# = copyAddrToByteArray# - --- |@setByteArray# ba off len c@ sets the byte range @[off, off+len]@ of --- the @MutableByteArray#@ to the byte @c@. --- --- __/Warning:/__ this can fail with an unchecked exception. -setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s -setByteArray# = setByteArray# - --- |Given an array and an offset in machine words, read an element. The --- index is assumed to be in bounds. Implies a full memory barrier. --- --- __/Warning:/__ this can fail with an unchecked exception. -atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -atomicReadIntArray# = atomicReadIntArray# - --- |Given an array and an offset in machine words, write an element. The --- index is assumed to be in bounds. Implies a full memory barrier. --- --- __/Warning:/__ this can fail with an unchecked exception. -atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -atomicWriteIntArray# = atomicWriteIntArray# - --- |Given an array, an offset in machine words, the expected old value, and --- the new value, perform an atomic compare and swap i.e. write the new --- value if the current value matches the provided old value. Returns --- the value of the element before the operation. Implies a full memory --- barrier. --- --- __/Warning:/__ this can fail with an unchecked exception. -casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #) -casIntArray# = casIntArray# - --- |Given an array, and offset in machine words, and a value to add, --- atomically add the value to the element. Returns the value of the --- element before the operation. Implies a full memory barrier. --- --- __/Warning:/__ this can fail with an unchecked exception. -fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchAddIntArray# = fetchAddIntArray# - --- |Given an array, and offset in machine words, and a value to subtract, --- atomically substract the value to the element. Returns the value of --- the element before the operation. Implies a full memory barrier. --- --- __/Warning:/__ this can fail with an unchecked exception. -fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchSubIntArray# = fetchSubIntArray# - --- |Given an array, and offset in machine words, and a value to AND, --- atomically AND the value to the element. Returns the value of the --- element before the operation. Implies a full memory barrier. --- --- __/Warning:/__ this can fail with an unchecked exception. -fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchAndIntArray# = fetchAndIntArray# - --- |Given an array, and offset in machine words, and a value to NAND, --- atomically NAND the value to the element. Returns the value of the --- element before the operation. Implies a full memory barrier. --- --- __/Warning:/__ this can fail with an unchecked exception. -fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchNandIntArray# = fetchNandIntArray# - --- |Given an array, and offset in machine words, and a value to OR, --- atomically OR the value to the element. Returns the value of the --- element before the operation. Implies a full memory barrier. --- --- __/Warning:/__ this can fail with an unchecked exception. -fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchOrIntArray# = fetchOrIntArray# - --- |Given an array, and offset in machine words, and a value to XOR, --- atomically XOR the value to the element. Returns the value of the --- element before the operation. Implies a full memory barrier. --- --- __/Warning:/__ this can fail with an unchecked exception. -fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchXorIntArray# = fetchXorIntArray# - -data ArrayArray# - -data MutableArrayArray# s - --- |Create a new mutable array of arrays with the specified number of elements, --- in the specified state thread, with each element recursively referring to the --- newly created array. -newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #) -newArrayArray# = newArrayArray# - -sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int# -sameMutableArrayArray# = sameMutableArrayArray# - --- |Make a mutable array of arrays immutable, without copying. -unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #) -unsafeFreezeArrayArray# = unsafeFreezeArrayArray# - --- |Return the number of elements in the array. -sizeofArrayArray# :: ArrayArray# -> Int# -sizeofArrayArray# = sizeofArrayArray# - --- |Return the number of elements in the array. -sizeofMutableArrayArray# :: MutableArrayArray# s -> Int# -sizeofMutableArrayArray# = sizeofMutableArrayArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray# -indexByteArrayArray# = indexByteArrayArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray# -indexArrayArrayArray# = indexArrayArrayArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #) -readByteArrayArray# = readByteArrayArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #) -readMutableByteArrayArray# = readMutableByteArrayArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #) -readArrayArrayArray# = readArrayArrayArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #) -readMutableArrayArrayArray# = readMutableArrayArrayArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s -writeByteArrayArray# = writeByteArrayArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s -writeMutableByteArrayArray# = writeMutableByteArrayArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s -writeArrayArrayArray# = writeArrayArrayArray# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s -writeMutableArrayArrayArray# = writeMutableArrayArrayArray# - --- |Copy a range of the ArrayArray\# to the specified region in the MutableArrayArray\#. --- Both arrays must fully contain the specified ranges, but this is not checked. --- The two arrays must not be the same array in different states, but this is not checked either. --- --- __/Warning:/__ this can fail with an unchecked exception. -copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s -copyArrayArray# = copyArrayArray# - --- |Copy a range of the first MutableArrayArray# to the specified region in the second --- MutableArrayArray#. --- Both arrays must fully contain the specified ranges, but this is not checked. --- The regions are allowed to overlap, although this is only possible when the same --- array is provided as both the source and the destination. --- --- --- __/Warning:/__ this can fail with an unchecked exception. -copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s -copyMutableArrayArray# = copyMutableArrayArray# - --- | An arbitrary machine address assumed to point outside --- the garbage-collected heap. -data Addr# - --- | The null address. -nullAddr# :: Addr# -nullAddr# = nullAddr# - -plusAddr# :: Addr# -> Int# -> Addr# -plusAddr# = plusAddr# - --- |Result is meaningless if two @Addr\#@s are so far apart that their --- difference doesn\'t fit in an @Int\#@. -minusAddr# :: Addr# -> Addr# -> Int# -minusAddr# = minusAddr# - --- |Return the remainder when the @Addr\#@ arg, treated like an @Int\#@, --- is divided by the @Int\#@ arg. -remAddr# :: Addr# -> Int# -> Int# -remAddr# = remAddr# - --- |Coerce directly from address to int. -{-# DEPRECATED addr2Int# " This operation is strongly deprecated. " #-} -addr2Int# :: Addr# -> Int# -addr2Int# = addr2Int# - --- |Coerce directly from int to address. -{-# DEPRECATED int2Addr# " This operation is strongly deprecated. " #-} -int2Addr# :: Int# -> Addr# -int2Addr# = int2Addr# - -gtAddr# :: Addr# -> Addr# -> Int# -gtAddr# = gtAddr# - -geAddr# :: Addr# -> Addr# -> Int# -geAddr# = geAddr# - -eqAddr# :: Addr# -> Addr# -> Int# -eqAddr# = eqAddr# - -neAddr# :: Addr# -> Addr# -> Int# -neAddr# = neAddr# - -ltAddr# :: Addr# -> Addr# -> Int# -ltAddr# = ltAddr# - -leAddr# :: Addr# -> Addr# -> Int# -leAddr# = leAddr# - --- |Reads 8-bit character; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexCharOffAddr# :: Addr# -> Int# -> Char# -indexCharOffAddr# = indexCharOffAddr# - --- |Reads 31-bit character; offset in 4-byte words. --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWideCharOffAddr# :: Addr# -> Int# -> Char# -indexWideCharOffAddr# = indexWideCharOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexIntOffAddr# :: Addr# -> Int# -> Int# -indexIntOffAddr# = indexIntOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWordOffAddr# :: Addr# -> Int# -> Word# -indexWordOffAddr# = indexWordOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexAddrOffAddr# :: Addr# -> Int# -> Addr# -indexAddrOffAddr# = indexAddrOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexFloatOffAddr# :: Addr# -> Int# -> Float# -indexFloatOffAddr# = indexFloatOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexDoubleOffAddr# :: Addr# -> Int# -> Double# -indexDoubleOffAddr# = indexDoubleOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -indexStablePtrOffAddr# = indexStablePtrOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexInt8OffAddr# :: Addr# -> Int# -> Int# -indexInt8OffAddr# = indexInt8OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexInt16OffAddr# :: Addr# -> Int# -> Int# -indexInt16OffAddr# = indexInt16OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexInt32OffAddr# :: Addr# -> Int# -> Int# -indexInt32OffAddr# = indexInt32OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexInt64OffAddr# :: Addr# -> Int# -> Int# -indexInt64OffAddr# = indexInt64OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord8OffAddr# :: Addr# -> Int# -> Word# -indexWord8OffAddr# = indexWord8OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord16OffAddr# :: Addr# -> Int# -> Word# -indexWord16OffAddr# = indexWord16OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord32OffAddr# :: Addr# -> Int# -> Word# -indexWord32OffAddr# = indexWord32OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -indexWord64OffAddr# :: Addr# -> Int# -> Word# -indexWord64OffAddr# = indexWord64OffAddr# - --- |Reads 8-bit character; offset in bytes. --- --- __/Warning:/__ this can fail with an unchecked exception. -readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) -readCharOffAddr# = readCharOffAddr# - --- |Reads 31-bit character; offset in 4-byte words. --- --- __/Warning:/__ this can fail with an unchecked exception. -readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) -readWideCharOffAddr# = readWideCharOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) -readIntOffAddr# = readIntOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) -readWordOffAddr# = readWordOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #) -readAddrOffAddr# = readAddrOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #) -readFloatOffAddr# = readFloatOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #) -readDoubleOffAddr# = readDoubleOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #) -readStablePtrOffAddr# = readStablePtrOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) -readInt8OffAddr# = readInt8OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) -readInt16OffAddr# = readInt16OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) -readInt32OffAddr# = readInt32OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) -readInt64OffAddr# = readInt64OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) -readWord8OffAddr# = readWord8OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) -readWord16OffAddr# = readWord16OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) -readWord32OffAddr# = readWord32OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) -readWord64OffAddr# = readWord64OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s -writeCharOffAddr# = writeCharOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s -writeWideCharOffAddr# = writeWideCharOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s -writeIntOffAddr# = writeIntOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s -writeWordOffAddr# = writeWordOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s -writeAddrOffAddr# = writeAddrOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s -writeFloatOffAddr# = writeFloatOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s -writeDoubleOffAddr# = writeDoubleOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s -writeStablePtrOffAddr# = writeStablePtrOffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s -writeInt8OffAddr# = writeInt8OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s -writeInt16OffAddr# = writeInt16OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s -writeInt32OffAddr# = writeInt32OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s -writeInt64OffAddr# = writeInt64OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s -writeWord8OffAddr# = writeWord8OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s -writeWord16OffAddr# = writeWord16OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s -writeWord32OffAddr# = writeWord32OffAddr# - --- | --- --- __/Warning:/__ this can fail with an unchecked exception. -writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s -writeWord64OffAddr# = writeWord64OffAddr# - --- |A @MutVar\#@ behaves like a single-element mutable array. -data MutVar# s a - --- |Create @MutVar\#@ with specified initial value in specified state thread. -newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #) -newMutVar# = newMutVar# - --- |Read contents of @MutVar\#@. Result is not yet evaluated. -readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #) -readMutVar# = readMutVar# - --- |Write contents of @MutVar\#@. -writeMutVar# :: MutVar# s a -> a -> State# s -> State# s -writeMutVar# = writeMutVar# - -sameMutVar# :: MutVar# s a -> MutVar# s a -> Int# -sameMutVar# = sameMutVar# - --- | Modify the contents of a @MutVar\#@, returning the previous --- contents and the result of applying the given function to the --- previous contents. Note that this isn\'t strictly --- speaking the correct type for this function; it should really be --- @MutVar\# s a -> (a -> (a,b)) -> State\# s -> (\# State\# s, a, (a, b) \#)@, --- but we don\'t know about pairs here. --- --- __/Warning:/__ this can fail with an unchecked exception. -atomicModifyMutVar2# :: MutVar# s a -> (a -> c) -> State# s -> (# State# s,a,c #) -atomicModifyMutVar2# = atomicModifyMutVar2# - --- | Modify the contents of a @MutVar\#@, returning the previous --- contents and the result of applying the given function to the --- previous contents. --- --- __/Warning:/__ this can fail with an unchecked exception. -atomicModifyMutVar_# :: MutVar# s a -> (a -> a) -> State# s -> (# State# s,a,a #) -atomicModifyMutVar_# = atomicModifyMutVar_# - -casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #) -casMutVar# = casMutVar# - -catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -catch# = catch# - -raise# :: b -> o -raise# = raise# - -raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #) -raiseIO# = raiseIO# - -maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -maskAsyncExceptions# = maskAsyncExceptions# - -maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -maskUninterruptible# = maskUninterruptible# - -unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -unmaskAsyncExceptions# = unmaskAsyncExceptions# - -getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) -getMaskingState# = getMaskingState# - -data TVar# s a - -atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -atomically# = atomically# - -retry# :: State# (RealWorld) -> (# State# (RealWorld),a #) -retry# = retry# - -catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -catchRetry# = catchRetry# - -catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -catchSTM# = catchSTM# - --- |Create a new @TVar\#@ holding a specified initial value. -newTVar# :: a -> State# s -> (# State# s,TVar# s a #) -newTVar# = newTVar# - --- |Read contents of @TVar\#@. Result is not yet evaluated. -readTVar# :: TVar# s a -> State# s -> (# State# s,a #) -readTVar# = readTVar# - --- |Read contents of @TVar\#@ outside an STM transaction -readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #) -readTVarIO# = readTVarIO# - --- |Write contents of @TVar\#@. -writeTVar# :: TVar# s a -> a -> State# s -> State# s -writeTVar# = writeTVar# - -sameTVar# :: TVar# s a -> TVar# s a -> Int# -sameTVar# = sameTVar# - --- | A shared mutable variable (/not/ the same as a @MutVar\#@!). --- (Note: in a non-concurrent implementation, @(MVar\# a)@ can be --- represented by @(MutVar\# (Maybe a))@.) -data MVar# s a - --- |Create new @MVar\#@; initially empty. -newMVar# :: State# s -> (# State# s,MVar# s a #) -newMVar# = newMVar# - --- |If @MVar\#@ is empty, block until it becomes full. --- Then remove and return its contents, and set it empty. -takeMVar# :: MVar# s a -> State# s -> (# State# s,a #) -takeMVar# = takeMVar# - --- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined. --- Otherwise, return with integer 1 and contents of @MVar\#@, and set @MVar\#@ empty. -tryTakeMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #) -tryTakeMVar# = tryTakeMVar# - --- |If @MVar\#@ is full, block until it becomes empty. --- Then store value arg as its new contents. -putMVar# :: MVar# s a -> a -> State# s -> State# s -putMVar# = putMVar# - --- |If @MVar\#@ is full, immediately return with integer 0. --- Otherwise, store value arg as @MVar\#@\'s new contents, and return with integer 1. -tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s,Int# #) -tryPutMVar# = tryPutMVar# - --- |If @MVar\#@ is empty, block until it becomes full. --- Then read its contents without modifying the MVar, without possibility --- of intervention from other threads. -readMVar# :: MVar# s a -> State# s -> (# State# s,a #) -readMVar# = readMVar# - --- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined. --- Otherwise, return with integer 1 and contents of @MVar\#@. -tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #) -tryReadMVar# = tryReadMVar# - -sameMVar# :: MVar# s a -> MVar# s a -> Int# -sameMVar# = sameMVar# - --- |Return 1 if @MVar\#@ is empty; 0 otherwise. -isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #) -isEmptyMVar# = isEmptyMVar# - --- |Sleep specified number of microseconds. -delay# :: Int# -> State# s -> State# s -delay# = delay# - --- |Block until input is available on specified file descriptor. -waitRead# :: Int# -> State# s -> State# s -waitRead# = waitRead# - --- |Block until output is possible on specified file descriptor. -waitWrite# :: Int# -> State# s -> State# s -waitWrite# = waitWrite# - --- | @State\#@ is the primitive, unlifted type of states. It has --- one type parameter, thus @State\# RealWorld@, or @State\# s@, --- where s is a type variable. The only purpose of the type parameter --- is to keep different state threads separate. It is represented by --- nothing at all. -data State# s - --- | @RealWorld@ is deeply magical. It is /primitive/, but it is not --- /unlifted/ (hence @ptrArg@). We never manipulate values of type --- @RealWorld@; it\'s only used in the type system, to parameterise @State\#@. -data RealWorld - --- |(In a non-concurrent implementation, this can be a singleton --- type, whose (unique) value is returned by @myThreadId\#@. The --- other operations can be omitted.) -data ThreadId# - -fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) -fork# = fork# - -forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) -forkOn# = forkOn# - -killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld) -killThread# = killThread# - -yield# :: State# (RealWorld) -> State# (RealWorld) -yield# = yield# - -myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) -myThreadId# = myThreadId# - -labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld) -labelThread# = labelThread# - -isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) -isCurrentThreadBound# = isCurrentThreadBound# - -noDuplicate# :: State# s -> State# s -noDuplicate# = noDuplicate# - -threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #) -threadStatus# = threadStatus# - -data Weak# b - --- | @mkWeak# k v finalizer s@ creates a weak reference to value @k@, --- with an associated reference to some value @v@. If @k@ is still --- alive then @v@ can be retrieved using @deRefWeak#@. Note that --- the type of @k@ must be represented by a pointer (i.e. of kind @TYPE \'LiftedRep@ or @TYPE \'UnliftedRep@). -mkWeak# :: o -> b -> (State# (RealWorld) -> (# State# (RealWorld),c #)) -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) -mkWeak# = mkWeak# - -mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) -mkWeakNoFinalizer# = mkWeakNoFinalizer# - --- | @addCFinalizerToWeak# fptr ptr flag eptr w@ attaches a C --- function pointer @fptr@ to a weak pointer @w@ as a finalizer. If --- @flag@ is zero, @fptr@ will be called with one argument, --- @ptr@. Otherwise, it will be called with two arguments, --- @eptr@ and @ptr@. @addCFinalizerToWeak#@ returns --- 1 on success, or 0 if @w@ is already dead. -addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# (RealWorld) -> (# State# (RealWorld),Int# #) -addCFinalizerToWeak# = addCFinalizerToWeak# - -deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #) -deRefWeak# = deRefWeak# - --- | Finalize a weak pointer. The return value is an unboxed tuple --- containing the new state of the world and an \"unboxed Maybe\", --- represented by an @Int#@ and a (possibly invalid) finalization --- action. An @Int#@ of @1@ indicates that the finalizer is valid. The --- return value @b@ from the finalizer should be ignored. -finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),b #) #) -finalizeWeak# = finalizeWeak# - -touch# :: o -> State# (RealWorld) -> State# (RealWorld) -touch# = touch# - -data StablePtr# a - -data StableName# a - -makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #) -makeStablePtr# = makeStablePtr# - -deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #) -deRefStablePtr# = deRefStablePtr# - -eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int# -eqStablePtr# = eqStablePtr# - -makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #) -makeStableName# = makeStableName# - -eqStableName# :: StableName# a -> StableName# b -> Int# -eqStableName# = eqStableName# - -stableNameToInt# :: StableName# a -> Int# -stableNameToInt# = stableNameToInt# - -data Compact# - --- | Create a new CNF with a single compact block. The argument is --- the capacity of the compact block (in bytes, not words). --- The capacity is rounded up to a multiple of the allocator block size --- and is capped to one mega block. -compactNew# :: Word# -> State# (RealWorld) -> (# State# (RealWorld),Compact# #) -compactNew# = compactNew# - --- | Set the new allocation size of the CNF. This value (in bytes) --- determines the capacity of each compact block in the CNF. It --- does not retroactively affect existing compact blocks in the CNF. -compactResize# :: Compact# -> Word# -> State# (RealWorld) -> State# (RealWorld) -compactResize# = compactResize# - --- | Returns 1\# if the object is contained in the CNF, 0\# otherwise. -compactContains# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),Int# #) -compactContains# = compactContains# - --- | Returns 1\# if the object is in any CNF at all, 0\# otherwise. -compactContainsAny# :: a -> State# (RealWorld) -> (# State# (RealWorld),Int# #) -compactContainsAny# = compactContainsAny# - --- | Returns the address and the utilized size (in bytes) of the --- first compact block of a CNF. -compactGetFirstBlock# :: Compact# -> State# (RealWorld) -> (# State# (RealWorld),Addr#,Word# #) -compactGetFirstBlock# = compactGetFirstBlock# - --- | Given a CNF and the address of one its compact blocks, returns the --- next compact block and its utilized size, or @nullAddr\#@ if the --- argument was the last compact block in the CNF. -compactGetNextBlock# :: Compact# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Addr#,Word# #) -compactGetNextBlock# = compactGetNextBlock# - --- | Attempt to allocate a compact block with the capacity (in --- bytes) given by the first argument. The @Addr\#@ is a pointer --- to previous compact block of the CNF or @nullAddr\#@ to create a --- new CNF with a single compact block. --- --- The resulting block is not known to the GC until --- @compactFixupPointers\#@ is called on it, and care must be taken --- so that the address does not escape or memory will be leaked. --- -compactAllocateBlock# :: Word# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Addr# #) -compactAllocateBlock# = compactAllocateBlock# - --- | Given the pointer to the first block of a CNF and the --- address of the root object in the old address space, fix up --- the internal pointers inside the CNF to account for --- a different position in memory than when it was serialized. --- This method must be called exactly once after importing --- a serialized CNF. It returns the new CNF and the new adjusted --- root address. -compactFixupPointers# :: Addr# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Compact#,Addr# #) -compactFixupPointers# = compactFixupPointers# - --- | Recursively add a closure and its transitive closure to a --- @Compact\#@ (a CNF), evaluating any unevaluated components --- at the same time. Note: @compactAdd\#@ is not thread-safe, so --- only one thread may call @compactAdd\#@ with a particular --- @Compact\#@ at any given time. The primop does not --- enforce any mutual exclusion; the caller is expected to --- arrange this. -compactAdd# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),a #) -compactAdd# = compactAdd# - --- | Like @compactAdd\#@, but retains sharing and cycles --- during compaction. -compactAddWithSharing# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),a #) -compactAddWithSharing# = compactAddWithSharing# - --- | Return the total capacity (in bytes) of all the compact blocks --- in the CNF. -compactSize# :: Compact# -> State# (RealWorld) -> (# State# (RealWorld),Word# #) -compactSize# = compactSize# - --- | Returns @1\#@ if the given pointers are equal and @0\#@ otherwise. --- --- __/Warning:/__ this can fail with an unchecked exception. -reallyUnsafePtrEquality# :: a -> a -> Int# -reallyUnsafePtrEquality# = reallyUnsafePtrEquality# - -{-# DEPRECATED par# " Use 'spark#' instead " #-} -par# :: a -> Int# -par# = par# - -spark# :: a -> State# s -> (# State# s,a #) -spark# = spark# - -seq# :: a -> State# s -> (# State# s,a #) -seq# = seq# - -getSpark# :: State# s -> (# State# s,Int#,a #) -getSpark# = getSpark# - --- | Returns the number of sparks in the local spark pool. -numSparks# :: State# s -> (# State# s,Int# #) -numSparks# = numSparks# - -dataToTag# :: a -> Int# -dataToTag# = dataToTag# - -tagToEnum# :: Int# -> a -tagToEnum# = let x = x in x - --- | Primitive bytecode type. -data BCO# - --- | Convert an @Addr\#@ to a followable Any type. -addrToAny# :: Addr# -> (# a #) -addrToAny# = addrToAny# - --- | Retrieve the address of any Haskell value. This is --- essentially an @unsafeCoerce\#@, but if implemented as such --- the core lint pass complains and fails to compile. --- As a primop, it is opaque to core\/stg, and only appears --- in cmm (where the copy propagation pass will get rid of it). --- Note that \"a\" must be a value, not a thunk! It\'s too late --- for strictness analysis to enforce this, so you\'re on your --- own to guarantee this. Also note that @Addr\#@ is not a GC --- pointer - up to you to guarantee that it does not become --- a dangling pointer immediately after you get it. -anyToAddr# :: a -> State# (RealWorld) -> (# State# (RealWorld),Addr# #) -anyToAddr# = anyToAddr# - --- | Wrap a BCO in a @AP_UPD@ thunk which will be updated with the value of --- the BCO when evaluated. -mkApUpd0# :: BCO# -> (# a #) -mkApUpd0# = mkApUpd0# - --- | @newBCO\# instrs lits ptrs arity bitmap@ creates a new bytecode object. The --- resulting object encodes a function of the given arity with the instructions --- encoded in @instrs@, and a static reference table usage bitmap given by --- @bitmap@. -newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #) -newBCO# = newBCO# - --- | @unpackClosure\# closure@ copies the closure and pointers in the --- payload of the given closure into two new arrays, and returns a pointer to --- the first word of the closure\'s info table, a non-pointer array for the raw --- bytes of the closure, and a pointer array for the pointers in the payload. -unpackClosure# :: a -> (# Addr#,ByteArray#,Array# b #) -unpackClosure# = unpackClosure# - --- | @closureSize\# closure@ returns the size of the given closure in --- machine words. -closureSize# :: a -> Int# -closureSize# = closureSize# - -getApStackVal# :: a -> Int# -> (# Int#,b #) -getApStackVal# = getApStackVal# - -getCCSOf# :: a -> State# s -> (# State# s,Addr# #) -getCCSOf# = getCCSOf# - --- | Returns the current @CostCentreStack@ (value is @NULL@ if --- not profiling). Takes a dummy argument which can be used to --- avoid the call to @getCurrentCCS\#@ being floated out by the --- simplifier, which would result in an uninformative stack --- (\"CAF\"). -getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #) -getCurrentCCS# = getCurrentCCS# - --- | Run the supplied IO action with an empty CCS. For example, this --- is used by the interpreter to run an interpreted computation --- without the call stack showing that it was invoked from GHC. -clearCCS# :: (State# s -> (# State# s,a #)) -> State# s -> (# State# s,a #) -clearCCS# = clearCCS# - --- | The type constructor @Proxy#@ is used to bear witness to some --- type variable. It\'s used when you want to pass around proxy values --- for doing things like modelling type applications. A @Proxy#@ --- is not only unboxed, it also has a polymorphic kind, and has no --- runtime representation, being totally free. -data Proxy# a - --- | Witness for an unboxed @Proxy#@ value, which has no runtime --- representation. -proxy# :: Proxy# a -proxy# = proxy# - --- | The value of @seq a b@ is bottom if @a@ is bottom, and --- otherwise equal to @b@. In other words, it evaluates the first --- argument @a@ to weak head normal form (WHNF). @seq@ is usually --- introduced to improve performance by avoiding unneeded laziness. --- --- A note on evaluation order: the expression @seq a b@ does --- /not/ guarantee that @a@ will be evaluated before @b@. --- The only guarantee given by @seq@ is that the both @a@ --- and @b@ will be evaluated before @seq@ returns a value. --- In particular, this means that @b@ may be evaluated before --- @a@. If you need to guarantee a specific order of evaluation, --- you must use the function @pseq@ from the \"parallel\" package. -infixr 0 `seq` -seq :: a -> b -> b -seq = seq - --- | The function @unsafeCoerce\#@ allows you to side-step the typechecker entirely. That --- is, it allows you to coerce any type into any other type. If you use this function, --- you had better get it right, otherwise segmentation faults await. It is generally --- used when you want to write a program that you know is well-typed, but where Haskell\'s --- type system is not expressive enough to prove that it is well typed. --- --- The following uses of @unsafeCoerce\#@ are supposed to work (i.e. not lead to --- spurious compile-time or run-time crashes): --- --- * Casting any lifted type to @Any@ --- --- * Casting @Any@ back to the real type --- --- * Casting an unboxed type to another unboxed type of the same size. --- (Casting between floating-point and integral types does not work. --- See the @GHC.Float@ module for functions to do work.) --- --- * Casting between two types that have the same runtime representation. One case is when --- the two types differ only in \"phantom\" type parameters, for example --- @Ptr Int@ to @Ptr Float@, or @[Int]@ to @[Float]@ when the list is --- known to be empty. Also, a @newtype@ of a type @T@ has the same representation --- at runtime as @T@. --- --- Other uses of @unsafeCoerce\#@ are undefined. In particular, you should not use --- @unsafeCoerce\#@ to cast a T to an algebraic data type D, unless T is also --- an algebraic data type. For example, do not cast @Int->Int@ to @Bool@, even if --- you later cast that @Bool@ back to @Int->Int@ before applying it. The reasons --- have to do with GHC\'s internal representation details (for the cognoscenti, data values --- can be entered but function closures cannot). If you want a safe type to cast things --- to, use @Any@, which is not an algebraic data type. --- --- --- --- __/Warning:/__ this can fail with an unchecked exception. -unsafeCoerce# :: a -> b -unsafeCoerce# = unsafeCoerce# - --- | Emits an event via the RTS tracing framework. The contents --- of the event is the zero-terminated byte string passed as the first --- argument. The event will be emitted either to the @.eventlog@ file, --- or to stderr, depending on the runtime RTS flags. -traceEvent# :: Addr# -> State# s -> State# s -traceEvent# = traceEvent# - --- | Emits an event via the RTS tracing framework. The contents --- of the event is the binary object passed as the first argument with --- the the given length passed as the second argument. The event will be --- emitted to the @.eventlog@ file. -traceBinaryEvent# :: Addr# -> Int# -> State# s -> State# s -traceBinaryEvent# = traceBinaryEvent# - --- | Emits a marker event via the RTS tracing framework. The contents --- of the event is the zero-terminated byte string passed as the first --- argument. The event will be emitted either to the @.eventlog@ file, --- or to stderr, depending on the runtime RTS flags. -traceMarker# :: Addr# -> State# s -> State# s -traceMarker# = traceMarker# - --- | Sets the allocation counter for the current thread to the given value. -setThreadAllocationCounter# :: Int# -> State# (RealWorld) -> State# (RealWorld) -setThreadAllocationCounter# = setThreadAllocationCounter# - --- | The function @coerce@ allows you to safely convert between values of --- types that have the same representation with no run-time overhead. In the --- simplest case you can use it instead of a newtype constructor, to go from --- the newtype\'s concrete type to the abstract type. But it also works in --- more complicated settings, e.g. converting a list of newtypes to a list of --- concrete types. --- --- This function is runtime-representation polymorphic, but the --- @RuntimeRep@ type argument is marked as @Inferred@, meaning --- that it is not available for visible type application. This means --- the typechecker will accept @coerce \@Int \@Age 42@. --- -coerce :: Coercible a b => a -> b -coerce = coerce - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int8X16# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int16X8# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int32X4# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int64X2# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int8X32# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int16X16# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int32X8# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int64X4# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int8X64# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int16X32# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int32X16# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Int64X8# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word8X16# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word16X8# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word32X4# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word64X2# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word8X32# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word16X16# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word32X8# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word64X4# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word8X64# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word16X32# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word32X16# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data Word64X8# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data FloatX4# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data DoubleX2# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data FloatX8# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data DoubleX4# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data FloatX16# - --- | --- --- __/Warning:/__ this is only available on LLVM. -data DoubleX8# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt8X16# :: Int# -> Int8X16# -broadcastInt8X16# = broadcastInt8X16# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt16X8# :: Int# -> Int16X8# -broadcastInt16X8# = broadcastInt16X8# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt32X4# :: Int# -> Int32X4# -broadcastInt32X4# = broadcastInt32X4# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt64X2# :: Int# -> Int64X2# -broadcastInt64X2# = broadcastInt64X2# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt8X32# :: Int# -> Int8X32# -broadcastInt8X32# = broadcastInt8X32# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt16X16# :: Int# -> Int16X16# -broadcastInt16X16# = broadcastInt16X16# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt32X8# :: Int# -> Int32X8# -broadcastInt32X8# = broadcastInt32X8# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt64X4# :: Int# -> Int64X4# -broadcastInt64X4# = broadcastInt64X4# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt8X64# :: Int# -> Int8X64# -broadcastInt8X64# = broadcastInt8X64# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt16X32# :: Int# -> Int16X32# -broadcastInt16X32# = broadcastInt16X32# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt32X16# :: Int# -> Int32X16# -broadcastInt32X16# = broadcastInt32X16# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastInt64X8# :: Int# -> Int64X8# -broadcastInt64X8# = broadcastInt64X8# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord8X16# :: Word# -> Word8X16# -broadcastWord8X16# = broadcastWord8X16# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord16X8# :: Word# -> Word16X8# -broadcastWord16X8# = broadcastWord16X8# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord32X4# :: Word# -> Word32X4# -broadcastWord32X4# = broadcastWord32X4# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord64X2# :: Word# -> Word64X2# -broadcastWord64X2# = broadcastWord64X2# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord8X32# :: Word# -> Word8X32# -broadcastWord8X32# = broadcastWord8X32# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord16X16# :: Word# -> Word16X16# -broadcastWord16X16# = broadcastWord16X16# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord32X8# :: Word# -> Word32X8# -broadcastWord32X8# = broadcastWord32X8# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord64X4# :: Word# -> Word64X4# -broadcastWord64X4# = broadcastWord64X4# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord8X64# :: Word# -> Word8X64# -broadcastWord8X64# = broadcastWord8X64# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord16X32# :: Word# -> Word16X32# -broadcastWord16X32# = broadcastWord16X32# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord32X16# :: Word# -> Word32X16# -broadcastWord32X16# = broadcastWord32X16# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastWord64X8# :: Word# -> Word64X8# -broadcastWord64X8# = broadcastWord64X8# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastFloatX4# :: Float# -> FloatX4# -broadcastFloatX4# = broadcastFloatX4# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastDoubleX2# :: Double# -> DoubleX2# -broadcastDoubleX2# = broadcastDoubleX2# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastFloatX8# :: Float# -> FloatX8# -broadcastFloatX8# = broadcastFloatX8# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastDoubleX4# :: Double# -> DoubleX4# -broadcastDoubleX4# = broadcastDoubleX4# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastFloatX16# :: Float# -> FloatX16# -broadcastFloatX16# = broadcastFloatX16# - --- | Broadcast a scalar to all elements of a vector. --- --- __/Warning:/__ this is only available on LLVM. -broadcastDoubleX8# :: Double# -> DoubleX8# -broadcastDoubleX8# = broadcastDoubleX8# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt8X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X16# -packInt8X16# = packInt8X16# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt16X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X8# -packInt16X8# = packInt16X8# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt32X4# :: (# Int#,Int#,Int#,Int# #) -> Int32X4# -packInt32X4# = packInt32X4# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt64X2# :: (# Int#,Int# #) -> Int64X2# -packInt64X2# = packInt64X2# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt8X32# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X32# -packInt8X32# = packInt8X32# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt16X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X16# -packInt16X16# = packInt16X16# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt32X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X8# -packInt32X8# = packInt32X8# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt64X4# :: (# Int#,Int#,Int#,Int# #) -> Int64X4# -packInt64X4# = packInt64X4# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt8X64# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X64# -packInt8X64# = packInt8X64# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt16X32# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X32# -packInt16X32# = packInt16X32# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt32X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X16# -packInt32X16# = packInt32X16# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packInt64X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int64X8# -packInt64X8# = packInt64X8# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord8X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X16# -packWord8X16# = packWord8X16# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord16X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X8# -packWord16X8# = packWord16X8# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord32X4# :: (# Word#,Word#,Word#,Word# #) -> Word32X4# -packWord32X4# = packWord32X4# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord64X2# :: (# Word#,Word# #) -> Word64X2# -packWord64X2# = packWord64X2# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord8X32# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X32# -packWord8X32# = packWord8X32# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord16X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X16# -packWord16X16# = packWord16X16# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord32X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X8# -packWord32X8# = packWord32X8# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord64X4# :: (# Word#,Word#,Word#,Word# #) -> Word64X4# -packWord64X4# = packWord64X4# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord8X64# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X64# -packWord8X64# = packWord8X64# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord16X32# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X32# -packWord16X32# = packWord16X32# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord32X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X16# -packWord32X16# = packWord32X16# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packWord64X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word64X8# -packWord64X8# = packWord64X8# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packFloatX4# :: (# Float#,Float#,Float#,Float# #) -> FloatX4# -packFloatX4# = packFloatX4# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packDoubleX2# :: (# Double#,Double# #) -> DoubleX2# -packDoubleX2# = packDoubleX2# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packFloatX8# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX8# -packFloatX8# = packFloatX8# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packDoubleX4# :: (# Double#,Double#,Double#,Double# #) -> DoubleX4# -packDoubleX4# = packDoubleX4# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packFloatX16# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX16# -packFloatX16# = packFloatX16# - --- | Pack the elements of an unboxed tuple into a vector. --- --- __/Warning:/__ this is only available on LLVM. -packDoubleX8# :: (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) -> DoubleX8# -packDoubleX8# = packDoubleX8# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt8X16# :: Int8X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt8X16# = unpackInt8X16# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt16X8# :: Int16X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt16X8# = unpackInt16X8# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt32X4# :: Int32X4# -> (# Int#,Int#,Int#,Int# #) -unpackInt32X4# = unpackInt32X4# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt64X2# :: Int64X2# -> (# Int#,Int# #) -unpackInt64X2# = unpackInt64X2# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt8X32# :: Int8X32# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt8X32# = unpackInt8X32# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt16X16# :: Int16X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt16X16# = unpackInt16X16# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt32X8# :: Int32X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt32X8# = unpackInt32X8# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt64X4# :: Int64X4# -> (# Int#,Int#,Int#,Int# #) -unpackInt64X4# = unpackInt64X4# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt8X64# :: Int8X64# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt8X64# = unpackInt8X64# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt16X32# :: Int16X32# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt16X32# = unpackInt16X32# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt32X16# :: Int32X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt32X16# = unpackInt32X16# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackInt64X8# :: Int64X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt64X8# = unpackInt64X8# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord8X16# :: Word8X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord8X16# = unpackWord8X16# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord16X8# :: Word16X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord16X8# = unpackWord16X8# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord32X4# :: Word32X4# -> (# Word#,Word#,Word#,Word# #) -unpackWord32X4# = unpackWord32X4# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord64X2# :: Word64X2# -> (# Word#,Word# #) -unpackWord64X2# = unpackWord64X2# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord8X32# :: Word8X32# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord8X32# = unpackWord8X32# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord16X16# :: Word16X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord16X16# = unpackWord16X16# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord32X8# :: Word32X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord32X8# = unpackWord32X8# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord64X4# :: Word64X4# -> (# Word#,Word#,Word#,Word# #) -unpackWord64X4# = unpackWord64X4# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord8X64# :: Word8X64# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord8X64# = unpackWord8X64# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord16X32# :: Word16X32# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord16X32# = unpackWord16X32# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord32X16# :: Word32X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord32X16# = unpackWord32X16# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackWord64X8# :: Word64X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord64X8# = unpackWord64X8# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackFloatX4# :: FloatX4# -> (# Float#,Float#,Float#,Float# #) -unpackFloatX4# = unpackFloatX4# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackDoubleX2# :: DoubleX2# -> (# Double#,Double# #) -unpackDoubleX2# = unpackDoubleX2# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackFloatX8# :: FloatX8# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -unpackFloatX8# = unpackFloatX8# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackDoubleX4# :: DoubleX4# -> (# Double#,Double#,Double#,Double# #) -unpackDoubleX4# = unpackDoubleX4# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackFloatX16# :: FloatX16# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -unpackFloatX16# = unpackFloatX16# - --- | Unpack the elements of a vector into an unboxed tuple. # --- --- __/Warning:/__ this is only available on LLVM. -unpackDoubleX8# :: DoubleX8# -> (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) -unpackDoubleX8# = unpackDoubleX8# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16# -insertInt8X16# = insertInt8X16# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8# -insertInt16X8# = insertInt16X8# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4# -insertInt32X4# = insertInt32X4# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2# -insertInt64X2# = insertInt64X2# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32# -insertInt8X32# = insertInt8X32# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16# -insertInt16X16# = insertInt16X16# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8# -insertInt32X8# = insertInt32X8# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4# -insertInt64X4# = insertInt64X4# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64# -insertInt8X64# = insertInt8X64# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32# -insertInt16X32# = insertInt16X32# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16# -insertInt32X16# = insertInt32X16# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8# -insertInt64X8# = insertInt64X8# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16# -insertWord8X16# = insertWord8X16# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8# -insertWord16X8# = insertWord16X8# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4# -insertWord32X4# = insertWord32X4# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2# -insertWord64X2# = insertWord64X2# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32# -insertWord8X32# = insertWord8X32# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16# -insertWord16X16# = insertWord16X16# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8# -insertWord32X8# = insertWord32X8# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4# -insertWord64X4# = insertWord64X4# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64# -insertWord8X64# = insertWord8X64# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32# -insertWord16X32# = insertWord16X32# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16# -insertWord32X16# = insertWord32X16# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8# -insertWord64X8# = insertWord64X8# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4# -insertFloatX4# = insertFloatX4# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2# -insertDoubleX2# = insertDoubleX2# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8# -insertFloatX8# = insertFloatX8# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4# -insertDoubleX4# = insertDoubleX4# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16# -insertFloatX16# = insertFloatX16# - --- | Insert a scalar at the given position in a vector. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8# -insertDoubleX8# = insertDoubleX8# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# -plusInt8X16# = plusInt8X16# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# -plusInt16X8# = plusInt16X8# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# -plusInt32X4# = plusInt32X4# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# -plusInt64X2# = plusInt64X2# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# -plusInt8X32# = plusInt8X32# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# -plusInt16X16# = plusInt16X16# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# -plusInt32X8# = plusInt32X8# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# -plusInt64X4# = plusInt64X4# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# -plusInt8X64# = plusInt8X64# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# -plusInt16X32# = plusInt16X32# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# -plusInt32X16# = plusInt32X16# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# -plusInt64X8# = plusInt64X8# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# -plusWord8X16# = plusWord8X16# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# -plusWord16X8# = plusWord16X8# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# -plusWord32X4# = plusWord32X4# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# -plusWord64X2# = plusWord64X2# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# -plusWord8X32# = plusWord8X32# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# -plusWord16X16# = plusWord16X16# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# -plusWord32X8# = plusWord32X8# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# -plusWord64X4# = plusWord64X4# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# -plusWord8X64# = plusWord8X64# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# -plusWord16X32# = plusWord16X32# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# -plusWord32X16# = plusWord32X16# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# -plusWord64X8# = plusWord64X8# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -plusFloatX4# = plusFloatX4# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -plusDoubleX2# = plusDoubleX2# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -plusFloatX8# = plusFloatX8# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -plusDoubleX4# = plusDoubleX4# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -plusFloatX16# = plusFloatX16# - --- | Add two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -plusDoubleX8# = plusDoubleX8# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# -minusInt8X16# = minusInt8X16# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# -minusInt16X8# = minusInt16X8# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# -minusInt32X4# = minusInt32X4# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# -minusInt64X2# = minusInt64X2# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# -minusInt8X32# = minusInt8X32# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# -minusInt16X16# = minusInt16X16# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# -minusInt32X8# = minusInt32X8# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# -minusInt64X4# = minusInt64X4# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# -minusInt8X64# = minusInt8X64# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# -minusInt16X32# = minusInt16X32# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# -minusInt32X16# = minusInt32X16# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# -minusInt64X8# = minusInt64X8# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# -minusWord8X16# = minusWord8X16# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# -minusWord16X8# = minusWord16X8# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# -minusWord32X4# = minusWord32X4# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# -minusWord64X2# = minusWord64X2# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# -minusWord8X32# = minusWord8X32# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# -minusWord16X16# = minusWord16X16# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# -minusWord32X8# = minusWord32X8# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# -minusWord64X4# = minusWord64X4# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# -minusWord8X64# = minusWord8X64# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# -minusWord16X32# = minusWord16X32# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# -minusWord32X16# = minusWord32X16# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# -minusWord64X8# = minusWord64X8# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -minusFloatX4# = minusFloatX4# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -minusDoubleX2# = minusDoubleX2# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -minusFloatX8# = minusFloatX8# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -minusDoubleX4# = minusDoubleX4# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -minusFloatX16# = minusFloatX16# - --- | Subtract two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -minusDoubleX8# = minusDoubleX8# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# -timesInt8X16# = timesInt8X16# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# -timesInt16X8# = timesInt16X8# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# -timesInt32X4# = timesInt32X4# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# -timesInt64X2# = timesInt64X2# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# -timesInt8X32# = timesInt8X32# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# -timesInt16X16# = timesInt16X16# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# -timesInt32X8# = timesInt32X8# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# -timesInt64X4# = timesInt64X4# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# -timesInt8X64# = timesInt8X64# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# -timesInt16X32# = timesInt16X32# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# -timesInt32X16# = timesInt32X16# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# -timesInt64X8# = timesInt64X8# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# -timesWord8X16# = timesWord8X16# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# -timesWord16X8# = timesWord16X8# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# -timesWord32X4# = timesWord32X4# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# -timesWord64X2# = timesWord64X2# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# -timesWord8X32# = timesWord8X32# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# -timesWord16X16# = timesWord16X16# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# -timesWord32X8# = timesWord32X8# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# -timesWord64X4# = timesWord64X4# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# -timesWord8X64# = timesWord8X64# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# -timesWord16X32# = timesWord16X32# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# -timesWord32X16# = timesWord32X16# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# -timesWord64X8# = timesWord64X8# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -timesFloatX4# = timesFloatX4# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -timesDoubleX2# = timesDoubleX2# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -timesFloatX8# = timesFloatX8# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -timesDoubleX4# = timesDoubleX4# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -timesFloatX16# = timesFloatX16# - --- | Multiply two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM. -timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -timesDoubleX8# = timesDoubleX8# - --- | Divide two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -divideFloatX4# = divideFloatX4# - --- | Divide two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -divideDoubleX2# = divideDoubleX2# - --- | Divide two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -divideFloatX8# = divideFloatX8# - --- | Divide two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -divideDoubleX4# = divideDoubleX4# - --- | Divide two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -divideFloatX16# = divideFloatX16# - --- | Divide two vectors element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -divideDoubleX8# = divideDoubleX8# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# -quotInt8X16# = quotInt8X16# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# -quotInt16X8# = quotInt16X8# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# -quotInt32X4# = quotInt32X4# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# -quotInt64X2# = quotInt64X2# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# -quotInt8X32# = quotInt8X32# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# -quotInt16X16# = quotInt16X16# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# -quotInt32X8# = quotInt32X8# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# -quotInt64X4# = quotInt64X4# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# -quotInt8X64# = quotInt8X64# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# -quotInt16X32# = quotInt16X32# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# -quotInt32X16# = quotInt32X16# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# -quotInt64X8# = quotInt64X8# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# -quotWord8X16# = quotWord8X16# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# -quotWord16X8# = quotWord16X8# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# -quotWord32X4# = quotWord32X4# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# -quotWord64X2# = quotWord64X2# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# -quotWord8X32# = quotWord8X32# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# -quotWord16X16# = quotWord16X16# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# -quotWord32X8# = quotWord32X8# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# -quotWord64X4# = quotWord64X4# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# -quotWord8X64# = quotWord8X64# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# -quotWord16X32# = quotWord16X32# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# -quotWord32X16# = quotWord32X16# - --- | Rounds towards zero element-wise. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# -quotWord64X8# = quotWord64X8# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# -remInt8X16# = remInt8X16# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# -remInt16X8# = remInt16X8# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# -remInt32X4# = remInt32X4# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# -remInt64X2# = remInt64X2# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# -remInt8X32# = remInt8X32# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# -remInt16X16# = remInt16X16# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# -remInt32X8# = remInt32X8# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# -remInt64X4# = remInt64X4# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# -remInt8X64# = remInt8X64# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# -remInt16X32# = remInt16X32# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# -remInt32X16# = remInt32X16# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# -remInt64X8# = remInt64X8# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# -remWord8X16# = remWord8X16# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# -remWord16X8# = remWord16X8# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# -remWord32X4# = remWord32X4# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# -remWord64X2# = remWord64X2# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# -remWord8X32# = remWord8X32# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# -remWord16X16# = remWord16X16# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# -remWord32X8# = remWord32X8# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# -remWord64X4# = remWord64X4# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# -remWord8X64# = remWord8X64# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# -remWord16X32# = remWord16X32# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# -remWord32X16# = remWord32X16# - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# -remWord64X8# = remWord64X8# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt8X16# :: Int8X16# -> Int8X16# -negateInt8X16# = negateInt8X16# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt16X8# :: Int16X8# -> Int16X8# -negateInt16X8# = negateInt16X8# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt32X4# :: Int32X4# -> Int32X4# -negateInt32X4# = negateInt32X4# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt64X2# :: Int64X2# -> Int64X2# -negateInt64X2# = negateInt64X2# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt8X32# :: Int8X32# -> Int8X32# -negateInt8X32# = negateInt8X32# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt16X16# :: Int16X16# -> Int16X16# -negateInt16X16# = negateInt16X16# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt32X8# :: Int32X8# -> Int32X8# -negateInt32X8# = negateInt32X8# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt64X4# :: Int64X4# -> Int64X4# -negateInt64X4# = negateInt64X4# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt8X64# :: Int8X64# -> Int8X64# -negateInt8X64# = negateInt8X64# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt16X32# :: Int16X32# -> Int16X32# -negateInt16X32# = negateInt16X32# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt32X16# :: Int32X16# -> Int32X16# -negateInt32X16# = negateInt32X16# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateInt64X8# :: Int64X8# -> Int64X8# -negateInt64X8# = negateInt64X8# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateFloatX4# :: FloatX4# -> FloatX4# -negateFloatX4# = negateFloatX4# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateDoubleX2# :: DoubleX2# -> DoubleX2# -negateDoubleX2# = negateDoubleX2# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateFloatX8# :: FloatX8# -> FloatX8# -negateFloatX8# = negateFloatX8# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateDoubleX4# :: DoubleX4# -> DoubleX4# -negateDoubleX4# = negateDoubleX4# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateFloatX16# :: FloatX16# -> FloatX16# -negateFloatX16# = negateFloatX16# - --- | Negate element-wise. --- --- __/Warning:/__ this is only available on LLVM. -negateDoubleX8# :: DoubleX8# -> DoubleX8# -negateDoubleX8# = negateDoubleX8# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16# -indexInt8X16Array# = indexInt8X16Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8# -indexInt16X8Array# = indexInt16X8Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4# -indexInt32X4Array# = indexInt32X4Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2# -indexInt64X2Array# = indexInt64X2Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32# -indexInt8X32Array# = indexInt8X32Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16# -indexInt16X16Array# = indexInt16X16Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8# -indexInt32X8Array# = indexInt32X8Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4# -indexInt64X4Array# = indexInt64X4Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64# -indexInt8X64Array# = indexInt8X64Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32# -indexInt16X32Array# = indexInt16X32Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16# -indexInt32X16Array# = indexInt32X16Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8# -indexInt64X8Array# = indexInt64X8Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16# -indexWord8X16Array# = indexWord8X16Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8# -indexWord16X8Array# = indexWord16X8Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4# -indexWord32X4Array# = indexWord32X4Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2# -indexWord64X2Array# = indexWord64X2Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32# -indexWord8X32Array# = indexWord8X32Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16# -indexWord16X16Array# = indexWord16X16Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8# -indexWord32X8Array# = indexWord32X8Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4# -indexWord64X4Array# = indexWord64X4Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64# -indexWord8X64Array# = indexWord8X64Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32# -indexWord16X32Array# = indexWord16X32Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16# -indexWord32X16Array# = indexWord32X16Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8# -indexWord64X8Array# = indexWord64X8Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4# -indexFloatX4Array# = indexFloatX4Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2# -indexDoubleX2Array# = indexDoubleX2Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8# -indexFloatX8Array# = indexFloatX8Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4# -indexDoubleX4Array# = indexDoubleX4Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16# -indexFloatX16Array# = indexFloatX16Array# - --- | Read a vector from specified index of immutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8# -indexDoubleX8Array# = indexDoubleX8Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #) -readInt8X16Array# = readInt8X16Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #) -readInt16X8Array# = readInt16X8Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #) -readInt32X4Array# = readInt32X4Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #) -readInt64X2Array# = readInt64X2Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #) -readInt8X32Array# = readInt8X32Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #) -readInt16X16Array# = readInt16X16Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #) -readInt32X8Array# = readInt32X8Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #) -readInt64X4Array# = readInt64X4Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #) -readInt8X64Array# = readInt8X64Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #) -readInt16X32Array# = readInt16X32Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #) -readInt32X16Array# = readInt32X16Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #) -readInt64X8Array# = readInt64X8Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #) -readWord8X16Array# = readWord8X16Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #) -readWord16X8Array# = readWord16X8Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #) -readWord32X4Array# = readWord32X4Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #) -readWord64X2Array# = readWord64X2Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #) -readWord8X32Array# = readWord8X32Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #) -readWord16X16Array# = readWord16X16Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #) -readWord32X8Array# = readWord32X8Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #) -readWord64X4Array# = readWord64X4Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #) -readWord8X64Array# = readWord8X64Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #) -readWord16X32Array# = readWord16X32Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #) -readWord32X16Array# = readWord32X16Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #) -readWord64X8Array# = readWord64X8Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #) -readFloatX4Array# = readFloatX4Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleX2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #) -readDoubleX2Array# = readDoubleX2Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #) -readFloatX8Array# = readFloatX8Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #) -readDoubleX4Array# = readDoubleX4Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatX16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #) -readFloatX16Array# = readFloatX16Array# - --- | Read a vector from specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #) -readDoubleX8Array# = readDoubleX8Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8X16Array# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s -writeInt8X16Array# = writeInt8X16Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16X8Array# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s -writeInt16X8Array# = writeInt16X8Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32X4Array# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s -writeInt32X4Array# = writeInt32X4Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64X2Array# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s -writeInt64X2Array# = writeInt64X2Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8X32Array# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s -writeInt8X32Array# = writeInt8X32Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16X16Array# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s -writeInt16X16Array# = writeInt16X16Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32X8Array# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s -writeInt32X8Array# = writeInt32X8Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64X4Array# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s -writeInt64X4Array# = writeInt64X4Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8X64Array# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s -writeInt8X64Array# = writeInt8X64Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16X32Array# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s -writeInt16X32Array# = writeInt16X32Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32X16Array# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s -writeInt32X16Array# = writeInt32X16Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64X8Array# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s -writeInt64X8Array# = writeInt64X8Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8X16Array# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s -writeWord8X16Array# = writeWord8X16Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16X8Array# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s -writeWord16X8Array# = writeWord16X8Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32X4Array# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s -writeWord32X4Array# = writeWord32X4Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64X2Array# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s -writeWord64X2Array# = writeWord64X2Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8X32Array# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s -writeWord8X32Array# = writeWord8X32Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16X16Array# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s -writeWord16X16Array# = writeWord16X16Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32X8Array# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s -writeWord32X8Array# = writeWord32X8Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64X4Array# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s -writeWord64X4Array# = writeWord64X4Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8X64Array# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s -writeWord8X64Array# = writeWord8X64Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16X32Array# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s -writeWord16X32Array# = writeWord16X32Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32X16Array# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s -writeWord32X16Array# = writeWord32X16Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64X8Array# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s -writeWord64X8Array# = writeWord64X8Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatX4Array# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s -writeFloatX4Array# = writeFloatX4Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleX2Array# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s -writeDoubleX2Array# = writeDoubleX2Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatX8Array# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s -writeFloatX8Array# = writeFloatX8Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleX4Array# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s -writeDoubleX4Array# = writeDoubleX4Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatX16Array# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s -writeFloatX16Array# = writeFloatX16Array# - --- | Write a vector to specified index of mutable array. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleX8Array# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s -writeDoubleX8Array# = writeDoubleX8Array# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -indexInt8X16OffAddr# = indexInt8X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -indexInt16X8OffAddr# = indexInt16X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -indexInt32X4OffAddr# = indexInt32X4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -indexInt64X2OffAddr# = indexInt64X2OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -indexInt8X32OffAddr# = indexInt8X32OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -indexInt16X16OffAddr# = indexInt16X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -indexInt32X8OffAddr# = indexInt32X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -indexInt64X4OffAddr# = indexInt64X4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -indexInt8X64OffAddr# = indexInt8X64OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -indexInt16X32OffAddr# = indexInt16X32OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -indexInt32X16OffAddr# = indexInt32X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -indexInt64X8OffAddr# = indexInt64X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -indexWord8X16OffAddr# = indexWord8X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -indexWord16X8OffAddr# = indexWord16X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -indexWord32X4OffAddr# = indexWord32X4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -indexWord64X2OffAddr# = indexWord64X2OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -indexWord8X32OffAddr# = indexWord8X32OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -indexWord16X16OffAddr# = indexWord16X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -indexWord32X8OffAddr# = indexWord32X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -indexWord64X4OffAddr# = indexWord64X4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -indexWord8X64OffAddr# = indexWord8X64OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -indexWord16X32OffAddr# = indexWord16X32OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -indexWord32X16OffAddr# = indexWord32X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -indexWord64X8OffAddr# = indexWord64X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -indexFloatX4OffAddr# = indexFloatX4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -indexDoubleX2OffAddr# = indexDoubleX2OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -indexFloatX8OffAddr# = indexFloatX8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -indexDoubleX4OffAddr# = indexDoubleX4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -indexFloatX16OffAddr# = indexFloatX16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -indexDoubleX8OffAddr# = indexDoubleX8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #) -readInt8X16OffAddr# = readInt8X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #) -readInt16X8OffAddr# = readInt16X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #) -readInt32X4OffAddr# = readInt32X4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #) -readInt64X2OffAddr# = readInt64X2OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #) -readInt8X32OffAddr# = readInt8X32OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #) -readInt16X16OffAddr# = readInt16X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #) -readInt32X8OffAddr# = readInt32X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #) -readInt64X4OffAddr# = readInt64X4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #) -readInt8X64OffAddr# = readInt8X64OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #) -readInt16X32OffAddr# = readInt16X32OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #) -readInt32X16OffAddr# = readInt32X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #) -readInt64X8OffAddr# = readInt64X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #) -readWord8X16OffAddr# = readWord8X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #) -readWord16X8OffAddr# = readWord16X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #) -readWord32X4OffAddr# = readWord32X4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #) -readWord64X2OffAddr# = readWord64X2OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #) -readWord8X32OffAddr# = readWord8X32OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #) -readWord16X16OffAddr# = readWord16X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #) -readWord32X8OffAddr# = readWord32X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #) -readWord64X4OffAddr# = readWord64X4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #) -readWord8X64OffAddr# = readWord8X64OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #) -readWord16X32OffAddr# = readWord16X32OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #) -readWord32X16OffAddr# = readWord32X16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #) -readWord64X8OffAddr# = readWord64X8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #) -readFloatX4OffAddr# = readFloatX4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleX2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #) -readDoubleX2OffAddr# = readDoubleX2OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #) -readFloatX8OffAddr# = readFloatX8OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #) -readDoubleX4OffAddr# = readDoubleX4OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatX16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #) -readFloatX16OffAddr# = readFloatX16OffAddr# - --- | Reads vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #) -readDoubleX8OffAddr# = readDoubleX8OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s -writeInt8X16OffAddr# = writeInt8X16OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s -writeInt16X8OffAddr# = writeInt16X8OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s -writeInt32X4OffAddr# = writeInt32X4OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s -writeInt64X2OffAddr# = writeInt64X2OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s -writeInt8X32OffAddr# = writeInt8X32OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s -writeInt16X16OffAddr# = writeInt16X16OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s -writeInt32X8OffAddr# = writeInt32X8OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s -writeInt64X4OffAddr# = writeInt64X4OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s -writeInt8X64OffAddr# = writeInt8X64OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s -writeInt16X32OffAddr# = writeInt16X32OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s -writeInt32X16OffAddr# = writeInt32X16OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s -writeInt64X8OffAddr# = writeInt64X8OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s -writeWord8X16OffAddr# = writeWord8X16OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s -writeWord16X8OffAddr# = writeWord16X8OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s -writeWord32X4OffAddr# = writeWord32X4OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s -writeWord64X2OffAddr# = writeWord64X2OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s -writeWord8X32OffAddr# = writeWord8X32OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s -writeWord16X16OffAddr# = writeWord16X16OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s -writeWord32X8OffAddr# = writeWord32X8OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s -writeWord64X4OffAddr# = writeWord64X4OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s -writeWord8X64OffAddr# = writeWord8X64OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s -writeWord16X32OffAddr# = writeWord16X32OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s -writeWord32X16OffAddr# = writeWord32X16OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s -writeWord64X8OffAddr# = writeWord64X8OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s -writeFloatX4OffAddr# = writeFloatX4OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s -writeDoubleX2OffAddr# = writeDoubleX2OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s -writeFloatX8OffAddr# = writeFloatX8OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s -writeDoubleX4OffAddr# = writeDoubleX4OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s -writeFloatX16OffAddr# = writeFloatX16OffAddr# - --- | Write vector; offset in bytes. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s -writeDoubleX8OffAddr# = writeDoubleX8OffAddr# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16# -indexInt8ArrayAsInt8X16# = indexInt8ArrayAsInt8X16# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8# -indexInt16ArrayAsInt16X8# = indexInt16ArrayAsInt16X8# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4# -indexInt32ArrayAsInt32X4# = indexInt32ArrayAsInt32X4# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2# -indexInt64ArrayAsInt64X2# = indexInt64ArrayAsInt64X2# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32# -indexInt8ArrayAsInt8X32# = indexInt8ArrayAsInt8X32# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16# -indexInt16ArrayAsInt16X16# = indexInt16ArrayAsInt16X16# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8# -indexInt32ArrayAsInt32X8# = indexInt32ArrayAsInt32X8# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4# -indexInt64ArrayAsInt64X4# = indexInt64ArrayAsInt64X4# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64# -indexInt8ArrayAsInt8X64# = indexInt8ArrayAsInt8X64# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32# -indexInt16ArrayAsInt16X32# = indexInt16ArrayAsInt16X32# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16# -indexInt32ArrayAsInt32X16# = indexInt32ArrayAsInt32X16# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8# -indexInt64ArrayAsInt64X8# = indexInt64ArrayAsInt64X8# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16# -indexWord8ArrayAsWord8X16# = indexWord8ArrayAsWord8X16# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8# -indexWord16ArrayAsWord16X8# = indexWord16ArrayAsWord16X8# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4# -indexWord32ArrayAsWord32X4# = indexWord32ArrayAsWord32X4# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2# -indexWord64ArrayAsWord64X2# = indexWord64ArrayAsWord64X2# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32# -indexWord8ArrayAsWord8X32# = indexWord8ArrayAsWord8X32# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16# -indexWord16ArrayAsWord16X16# = indexWord16ArrayAsWord16X16# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8# -indexWord32ArrayAsWord32X8# = indexWord32ArrayAsWord32X8# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4# -indexWord64ArrayAsWord64X4# = indexWord64ArrayAsWord64X4# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64# -indexWord8ArrayAsWord8X64# = indexWord8ArrayAsWord8X64# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32# -indexWord16ArrayAsWord16X32# = indexWord16ArrayAsWord16X32# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16# -indexWord32ArrayAsWord32X16# = indexWord32ArrayAsWord32X16# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8# -indexWord64ArrayAsWord64X8# = indexWord64ArrayAsWord64X8# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4# -indexFloatArrayAsFloatX4# = indexFloatArrayAsFloatX4# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2# -indexDoubleArrayAsDoubleX2# = indexDoubleArrayAsDoubleX2# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8# -indexFloatArrayAsFloatX8# = indexFloatArrayAsFloatX8# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4# -indexDoubleArrayAsDoubleX4# = indexDoubleArrayAsDoubleX4# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16# -indexFloatArrayAsFloatX16# = indexFloatArrayAsFloatX16# - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8# -indexDoubleArrayAsDoubleX8# = indexDoubleArrayAsDoubleX8# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #) -readInt8ArrayAsInt8X16# = readInt8ArrayAsInt8X16# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #) -readInt16ArrayAsInt16X8# = readInt16ArrayAsInt16X8# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #) -readInt32ArrayAsInt32X4# = readInt32ArrayAsInt32X4# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #) -readInt64ArrayAsInt64X2# = readInt64ArrayAsInt64X2# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #) -readInt8ArrayAsInt8X32# = readInt8ArrayAsInt8X32# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #) -readInt16ArrayAsInt16X16# = readInt16ArrayAsInt16X16# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #) -readInt32ArrayAsInt32X8# = readInt32ArrayAsInt32X8# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #) -readInt64ArrayAsInt64X4# = readInt64ArrayAsInt64X4# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #) -readInt8ArrayAsInt8X64# = readInt8ArrayAsInt8X64# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #) -readInt16ArrayAsInt16X32# = readInt16ArrayAsInt16X32# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #) -readInt32ArrayAsInt32X16# = readInt32ArrayAsInt32X16# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #) -readInt64ArrayAsInt64X8# = readInt64ArrayAsInt64X8# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #) -readWord8ArrayAsWord8X16# = readWord8ArrayAsWord8X16# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #) -readWord16ArrayAsWord16X8# = readWord16ArrayAsWord16X8# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #) -readWord32ArrayAsWord32X4# = readWord32ArrayAsWord32X4# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #) -readWord64ArrayAsWord64X2# = readWord64ArrayAsWord64X2# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #) -readWord8ArrayAsWord8X32# = readWord8ArrayAsWord8X32# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #) -readWord16ArrayAsWord16X16# = readWord16ArrayAsWord16X16# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #) -readWord32ArrayAsWord32X8# = readWord32ArrayAsWord32X8# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #) -readWord64ArrayAsWord64X4# = readWord64ArrayAsWord64X4# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #) -readWord8ArrayAsWord8X64# = readWord8ArrayAsWord8X64# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #) -readWord16ArrayAsWord16X32# = readWord16ArrayAsWord16X32# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #) -readWord32ArrayAsWord32X16# = readWord32ArrayAsWord32X16# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #) -readWord64ArrayAsWord64X8# = readWord64ArrayAsWord64X8# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #) -readFloatArrayAsFloatX4# = readFloatArrayAsFloatX4# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #) -readDoubleArrayAsDoubleX2# = readDoubleArrayAsDoubleX2# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #) -readFloatArrayAsFloatX8# = readFloatArrayAsFloatX8# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #) -readDoubleArrayAsDoubleX4# = readDoubleArrayAsDoubleX4# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #) -readFloatArrayAsFloatX16# = readFloatArrayAsFloatX16# - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #) -readDoubleArrayAsDoubleX8# = readDoubleArrayAsDoubleX8# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s -writeInt8ArrayAsInt8X16# = writeInt8ArrayAsInt8X16# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s -writeInt16ArrayAsInt16X8# = writeInt16ArrayAsInt16X8# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s -writeInt32ArrayAsInt32X4# = writeInt32ArrayAsInt32X4# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s -writeInt64ArrayAsInt64X2# = writeInt64ArrayAsInt64X2# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s -writeInt8ArrayAsInt8X32# = writeInt8ArrayAsInt8X32# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s -writeInt16ArrayAsInt16X16# = writeInt16ArrayAsInt16X16# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s -writeInt32ArrayAsInt32X8# = writeInt32ArrayAsInt32X8# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s -writeInt64ArrayAsInt64X4# = writeInt64ArrayAsInt64X4# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s -writeInt8ArrayAsInt8X64# = writeInt8ArrayAsInt8X64# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s -writeInt16ArrayAsInt16X32# = writeInt16ArrayAsInt16X32# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s -writeInt32ArrayAsInt32X16# = writeInt32ArrayAsInt32X16# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s -writeInt64ArrayAsInt64X8# = writeInt64ArrayAsInt64X8# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s -writeWord8ArrayAsWord8X16# = writeWord8ArrayAsWord8X16# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s -writeWord16ArrayAsWord16X8# = writeWord16ArrayAsWord16X8# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s -writeWord32ArrayAsWord32X4# = writeWord32ArrayAsWord32X4# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s -writeWord64ArrayAsWord64X2# = writeWord64ArrayAsWord64X2# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s -writeWord8ArrayAsWord8X32# = writeWord8ArrayAsWord8X32# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s -writeWord16ArrayAsWord16X16# = writeWord16ArrayAsWord16X16# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s -writeWord32ArrayAsWord32X8# = writeWord32ArrayAsWord32X8# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s -writeWord64ArrayAsWord64X4# = writeWord64ArrayAsWord64X4# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s -writeWord8ArrayAsWord8X64# = writeWord8ArrayAsWord8X64# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s -writeWord16ArrayAsWord16X32# = writeWord16ArrayAsWord16X32# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s -writeWord32ArrayAsWord32X16# = writeWord32ArrayAsWord32X16# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s -writeWord64ArrayAsWord64X8# = writeWord64ArrayAsWord64X8# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s -writeFloatArrayAsFloatX4# = writeFloatArrayAsFloatX4# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s -writeDoubleArrayAsDoubleX2# = writeDoubleArrayAsDoubleX2# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s -writeFloatArrayAsFloatX8# = writeFloatArrayAsFloatX8# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s -writeDoubleArrayAsDoubleX4# = writeDoubleArrayAsDoubleX4# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s -writeFloatArrayAsFloatX16# = writeFloatArrayAsFloatX16# - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s -writeDoubleArrayAsDoubleX8# = writeDoubleArrayAsDoubleX8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -indexInt8OffAddrAsInt8X16# = indexInt8OffAddrAsInt8X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -indexInt16OffAddrAsInt16X8# = indexInt16OffAddrAsInt16X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -indexInt32OffAddrAsInt32X4# = indexInt32OffAddrAsInt32X4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -indexInt64OffAddrAsInt64X2# = indexInt64OffAddrAsInt64X2# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -indexInt8OffAddrAsInt8X32# = indexInt8OffAddrAsInt8X32# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -indexInt16OffAddrAsInt16X16# = indexInt16OffAddrAsInt16X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -indexInt32OffAddrAsInt32X8# = indexInt32OffAddrAsInt32X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -indexInt64OffAddrAsInt64X4# = indexInt64OffAddrAsInt64X4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -indexInt8OffAddrAsInt8X64# = indexInt8OffAddrAsInt8X64# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -indexInt16OffAddrAsInt16X32# = indexInt16OffAddrAsInt16X32# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -indexInt32OffAddrAsInt32X16# = indexInt32OffAddrAsInt32X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -indexInt64OffAddrAsInt64X8# = indexInt64OffAddrAsInt64X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -indexWord8OffAddrAsWord8X16# = indexWord8OffAddrAsWord8X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -indexWord16OffAddrAsWord16X8# = indexWord16OffAddrAsWord16X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -indexWord32OffAddrAsWord32X4# = indexWord32OffAddrAsWord32X4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -indexWord64OffAddrAsWord64X2# = indexWord64OffAddrAsWord64X2# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -indexWord8OffAddrAsWord8X32# = indexWord8OffAddrAsWord8X32# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -indexWord16OffAddrAsWord16X16# = indexWord16OffAddrAsWord16X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -indexWord32OffAddrAsWord32X8# = indexWord32OffAddrAsWord32X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -indexWord64OffAddrAsWord64X4# = indexWord64OffAddrAsWord64X4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -indexWord8OffAddrAsWord8X64# = indexWord8OffAddrAsWord8X64# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -indexWord16OffAddrAsWord16X32# = indexWord16OffAddrAsWord16X32# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -indexWord32OffAddrAsWord32X16# = indexWord32OffAddrAsWord32X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -indexWord64OffAddrAsWord64X8# = indexWord64OffAddrAsWord64X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -indexFloatOffAddrAsFloatX4# = indexFloatOffAddrAsFloatX4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -indexDoubleOffAddrAsDoubleX2# = indexDoubleOffAddrAsDoubleX2# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -indexFloatOffAddrAsFloatX8# = indexFloatOffAddrAsFloatX8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -indexDoubleOffAddrAsDoubleX4# = indexDoubleOffAddrAsDoubleX4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -indexFloatOffAddrAsFloatX16# = indexFloatOffAddrAsFloatX16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -indexDoubleOffAddrAsDoubleX8# = indexDoubleOffAddrAsDoubleX8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #) -readInt8OffAddrAsInt8X16# = readInt8OffAddrAsInt8X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #) -readInt16OffAddrAsInt16X8# = readInt16OffAddrAsInt16X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #) -readInt32OffAddrAsInt32X4# = readInt32OffAddrAsInt32X4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #) -readInt64OffAddrAsInt64X2# = readInt64OffAddrAsInt64X2# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #) -readInt8OffAddrAsInt8X32# = readInt8OffAddrAsInt8X32# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #) -readInt16OffAddrAsInt16X16# = readInt16OffAddrAsInt16X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #) -readInt32OffAddrAsInt32X8# = readInt32OffAddrAsInt32X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #) -readInt64OffAddrAsInt64X4# = readInt64OffAddrAsInt64X4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #) -readInt8OffAddrAsInt8X64# = readInt8OffAddrAsInt8X64# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #) -readInt16OffAddrAsInt16X32# = readInt16OffAddrAsInt16X32# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #) -readInt32OffAddrAsInt32X16# = readInt32OffAddrAsInt32X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #) -readInt64OffAddrAsInt64X8# = readInt64OffAddrAsInt64X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #) -readWord8OffAddrAsWord8X16# = readWord8OffAddrAsWord8X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #) -readWord16OffAddrAsWord16X8# = readWord16OffAddrAsWord16X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #) -readWord32OffAddrAsWord32X4# = readWord32OffAddrAsWord32X4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #) -readWord64OffAddrAsWord64X2# = readWord64OffAddrAsWord64X2# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #) -readWord8OffAddrAsWord8X32# = readWord8OffAddrAsWord8X32# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #) -readWord16OffAddrAsWord16X16# = readWord16OffAddrAsWord16X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #) -readWord32OffAddrAsWord32X8# = readWord32OffAddrAsWord32X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #) -readWord64OffAddrAsWord64X4# = readWord64OffAddrAsWord64X4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #) -readWord8OffAddrAsWord8X64# = readWord8OffAddrAsWord8X64# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #) -readWord16OffAddrAsWord16X32# = readWord16OffAddrAsWord16X32# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #) -readWord32OffAddrAsWord32X16# = readWord32OffAddrAsWord32X16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #) -readWord64OffAddrAsWord64X8# = readWord64OffAddrAsWord64X8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #) -readFloatOffAddrAsFloatX4# = readFloatOffAddrAsFloatX4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #) -readDoubleOffAddrAsDoubleX2# = readDoubleOffAddrAsDoubleX2# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #) -readFloatOffAddrAsFloatX8# = readFloatOffAddrAsFloatX8# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #) -readDoubleOffAddrAsDoubleX4# = readDoubleOffAddrAsDoubleX4# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #) -readFloatOffAddrAsFloatX16# = readFloatOffAddrAsFloatX16# - --- | Reads vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #) -readDoubleOffAddrAsDoubleX8# = readDoubleOffAddrAsDoubleX8# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s -writeInt8OffAddrAsInt8X16# = writeInt8OffAddrAsInt8X16# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s -writeInt16OffAddrAsInt16X8# = writeInt16OffAddrAsInt16X8# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s -writeInt32OffAddrAsInt32X4# = writeInt32OffAddrAsInt32X4# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s -writeInt64OffAddrAsInt64X2# = writeInt64OffAddrAsInt64X2# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s -writeInt8OffAddrAsInt8X32# = writeInt8OffAddrAsInt8X32# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s -writeInt16OffAddrAsInt16X16# = writeInt16OffAddrAsInt16X16# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s -writeInt32OffAddrAsInt32X8# = writeInt32OffAddrAsInt32X8# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s -writeInt64OffAddrAsInt64X4# = writeInt64OffAddrAsInt64X4# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s -writeInt8OffAddrAsInt8X64# = writeInt8OffAddrAsInt8X64# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s -writeInt16OffAddrAsInt16X32# = writeInt16OffAddrAsInt16X32# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s -writeInt32OffAddrAsInt32X16# = writeInt32OffAddrAsInt32X16# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s -writeInt64OffAddrAsInt64X8# = writeInt64OffAddrAsInt64X8# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s -writeWord8OffAddrAsWord8X16# = writeWord8OffAddrAsWord8X16# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s -writeWord16OffAddrAsWord16X8# = writeWord16OffAddrAsWord16X8# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s -writeWord32OffAddrAsWord32X4# = writeWord32OffAddrAsWord32X4# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s -writeWord64OffAddrAsWord64X2# = writeWord64OffAddrAsWord64X2# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s -writeWord8OffAddrAsWord8X32# = writeWord8OffAddrAsWord8X32# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s -writeWord16OffAddrAsWord16X16# = writeWord16OffAddrAsWord16X16# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s -writeWord32OffAddrAsWord32X8# = writeWord32OffAddrAsWord32X8# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s -writeWord64OffAddrAsWord64X4# = writeWord64OffAddrAsWord64X4# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s -writeWord8OffAddrAsWord8X64# = writeWord8OffAddrAsWord8X64# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s -writeWord16OffAddrAsWord16X32# = writeWord16OffAddrAsWord16X32# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s -writeWord32OffAddrAsWord32X16# = writeWord32OffAddrAsWord32X16# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s -writeWord64OffAddrAsWord64X8# = writeWord64OffAddrAsWord64X8# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s -writeFloatOffAddrAsFloatX4# = writeFloatOffAddrAsFloatX4# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s -writeDoubleOffAddrAsDoubleX2# = writeDoubleOffAddrAsDoubleX2# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s -writeFloatOffAddrAsFloatX8# = writeFloatOffAddrAsFloatX8# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s -writeDoubleOffAddrAsDoubleX4# = writeDoubleOffAddrAsDoubleX4# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s -writeFloatOffAddrAsFloatX16# = writeFloatOffAddrAsFloatX16# - --- | Write vector; offset in scalar elements. --- --- __/Warning:/__ this is only available on LLVM and can fail with an unchecked exception. -writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s -writeDoubleOffAddrAsDoubleX8# = writeDoubleOffAddrAsDoubleX8# - -prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s -prefetchByteArray3# = prefetchByteArray3# - -prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s -prefetchMutableByteArray3# = prefetchMutableByteArray3# - -prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s -prefetchAddr3# = prefetchAddr3# - -prefetchValue3# :: a -> State# s -> State# s -prefetchValue3# = prefetchValue3# - -prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s -prefetchByteArray2# = prefetchByteArray2# - -prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s -prefetchMutableByteArray2# = prefetchMutableByteArray2# - -prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s -prefetchAddr2# = prefetchAddr2# - -prefetchValue2# :: a -> State# s -> State# s -prefetchValue2# = prefetchValue2# - -prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s -prefetchByteArray1# = prefetchByteArray1# - -prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s -prefetchMutableByteArray1# = prefetchMutableByteArray1# - -prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s -prefetchAddr1# = prefetchAddr1# - -prefetchValue1# :: a -> State# s -> State# s -prefetchValue1# = prefetchValue1# - -prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s -prefetchByteArray0# = prefetchByteArray0# - -prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s -prefetchMutableByteArray0# = prefetchMutableByteArray0# - -prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s -prefetchAddr0# = prefetchAddr0# - -prefetchValue0# :: a -> State# s -> State# s -prefetchValue0# = prefetchValue0# - - - diff --git a/GHC/Prim/Exception.hs b/GHC/Prim/Exception.hs new file mode 100644 --- /dev/null +++ b/GHC/Prim/Exception.hs @@ -0,0 +1,52 @@ +{-# LANGUAGE GHCForeignImportPrim #-} +{-# LANGUAGE UnliftedFFITypes #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE UnboxedTuples #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE EmptyCase #-} + +-- | Primitive exceptions. +module GHC.Prim.Exception + ( raiseOverflow + , raiseUnderflow + , raiseDivZero + ) +where + +import GHC.Prim +import GHC.Magic + +default () -- Double and Integer aren't available yet + +-- Note [Arithmetic exceptions] +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- +-- ghc-prim provides several functions to raise arithmetic exceptions +-- (raiseDivZero, raiseUnderflow, raiseOverflow) that are wired-in the RTS. +-- These exceptions are meant to be used by the package implementing arbitrary +-- precision numbers (Natural,Integer). It can't depend on `base` package to +-- raise exceptions in a normal way because it would create a dependency +-- cycle (base <-> bignum package). See #14664 + +foreign import prim "stg_raiseOverflowzh" raiseOverflow# :: State# RealWorld -> (# State# RealWorld, Void# #) +foreign import prim "stg_raiseUnderflowzh" raiseUnderflow# :: State# RealWorld -> (# State# RealWorld, Void# #) +foreign import prim "stg_raiseDivZZerozh" raiseDivZero# :: State# RealWorld -> (# State# RealWorld, Void# #) + +-- We give a bottoming demand signature to 'raiseOverflow', 'raiseUnderflow' and +-- 'raiseDivZero' in "GHC.Core.Make". NOINLINE pragmas are necessary because if +-- we ever inlined them we would lose that information. + +-- | Raise 'GHC.Exception.Type.overflowException' +raiseOverflow :: a +{-# NOINLINE raiseOverflow #-} +raiseOverflow = runRW# (\s -> case raiseOverflow# s of (# _, _ #) -> let x = x in x) + +-- | Raise 'GHC.Exception.Type.underflowException' +raiseUnderflow :: a +{-# NOINLINE raiseUnderflow #-} +raiseUnderflow = runRW# (\s -> case raiseUnderflow# s of (# _, _ #) -> let x = x in x) + +-- | Raise 'GHC.Exception.Type.divZeroException' +raiseDivZero :: a +{-# NOINLINE raiseDivZero #-} +raiseDivZero = runRW# (\s -> case raiseDivZero# s of (# _, _ #) -> let x = x in x) diff --git a/GHC/Prim/Panic.hs b/GHC/Prim/Panic.hs new file mode 100644 --- /dev/null +++ b/GHC/Prim/Panic.hs @@ -0,0 +1,45 @@ +{-# LANGUAGE GHCForeignImportPrim #-} +{-# LANGUAGE UnliftedFFITypes #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE UnboxedTuples #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE EmptyCase #-} + +-- | Primitive panics. +module GHC.Prim.Panic + ( absentSumFieldError + , panicError + ) +where + +import GHC.Prim +import GHC.Magic + +default () -- Double and Integer aren't available yet + +-- `stg_panic#` never returns but it can't just return `State# RealWorld` so we +-- indicate that it returns `Void#` too to make the compiler happy. +foreign import prim "stg_paniczh" panic# :: Addr# -> State# RealWorld -> (# State# RealWorld, Void# #) + +-- | Display the CString whose address is given as an argument and exit. +panicError :: Addr# -> a +panicError errmsg = + runRW# (\s -> + case panic# errmsg s of + (# _, _ #) -> -- This bottom is unreachable but we can't + -- use an empty case lest the pattern match + -- checker squawks. + let x = x in x) + +-- | Closure introduced by GHC.Stg.Unarise for unused unboxed sum fields. +-- +-- See Note [aBSENT_SUM_FIELD_ERROR_ID] in GHC.Core.Make +absentSumFieldError :: a +absentSumFieldError = panicError "entered absent sum field!"# + +-- GHC.Core.Make.aBSENT_SUM_FIELD_ERROR_ID gives absentSumFieldError a bottoming +-- demand signature. But if we ever inlined it (to a call to panicError) we'd +-- lose that information. Should not happen because absentSumFieldError is only +-- introduced in Stg.Unarise, long after inlining has stopped, but it seems +-- more direct simply to give it a NOINLINE pragma +{-# NOINLINE absentSumFieldError #-} diff --git a/GHC/PrimopWrappers.hs b/GHC/PrimopWrappers.hs --- a/GHC/PrimopWrappers.hs +++ b/GHC/PrimopWrappers.hs @@ -3,7 +3,7 @@ module GHC.PrimopWrappers where import qualified GHC.Prim import GHC.Tuple () -import GHC.Prim (Char#, Int#, Word#, Float#, Double#, Int8#, Word8#, Int16#, Word16#, State#, MutableArray#, Array#, SmallMutableArray#, SmallArray#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, MutableArrayArray#, ArrayArray#, MutVar#, RealWorld, TVar#, MVar#, ThreadId#, Weak#, StableName#, Compact#, BCO#) +import GHC.Prim (Char#, Int#, Int8#, Word8#, Word#, Int16#, Word16#, Float#, Double#, State#, MutableArray#, Array#, SmallMutableArray#, SmallArray#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, MutableArrayArray#, ArrayArray#, MutVar#, RealWorld, TVar#, MVar#, IOPort#, ThreadId#, Weak#, StableName#, Compact#, BCO) {-# NOINLINE gtChar# #-} gtChar# :: Char# -> Char# -> Int# gtChar# a1 a2 = (GHC.Prim.gtChar#) a1 a2 @@ -25,93 +25,6 @@ {-# NOINLINE ord# #-} ord# :: Char# -> Int# ord# a1 = (GHC.Prim.ord#) a1 -{-# NOINLINE (+#) #-} -(+#) :: Int# -> Int# -> Int# -(+#) a1 a2 = (GHC.Prim.+#) a1 a2 -{-# NOINLINE (-#) #-} -(-#) :: Int# -> Int# -> Int# -(-#) a1 a2 = (GHC.Prim.-#) a1 a2 -{-# NOINLINE (*#) #-} -(*#) :: Int# -> Int# -> Int# -(*#) a1 a2 = (GHC.Prim.*#) a1 a2 -{-# NOINLINE mulIntMayOflo# #-} -mulIntMayOflo# :: Int# -> Int# -> Int# -mulIntMayOflo# a1 a2 = (GHC.Prim.mulIntMayOflo#) a1 a2 -{-# NOINLINE quotInt# #-} -quotInt# :: Int# -> Int# -> Int# -quotInt# a1 a2 = (GHC.Prim.quotInt#) a1 a2 -{-# NOINLINE remInt# #-} -remInt# :: Int# -> Int# -> Int# -remInt# a1 a2 = (GHC.Prim.remInt#) a1 a2 -{-# NOINLINE quotRemInt# #-} -quotRemInt# :: Int# -> Int# -> (# Int#,Int# #) -quotRemInt# a1 a2 = (GHC.Prim.quotRemInt#) a1 a2 -{-# NOINLINE andI# #-} -andI# :: Int# -> Int# -> Int# -andI# a1 a2 = (GHC.Prim.andI#) a1 a2 -{-# NOINLINE orI# #-} -orI# :: Int# -> Int# -> Int# -orI# a1 a2 = (GHC.Prim.orI#) a1 a2 -{-# NOINLINE xorI# #-} -xorI# :: Int# -> Int# -> Int# -xorI# a1 a2 = (GHC.Prim.xorI#) a1 a2 -{-# NOINLINE notI# #-} -notI# :: Int# -> Int# -notI# a1 = (GHC.Prim.notI#) a1 -{-# NOINLINE negateInt# #-} -negateInt# :: Int# -> Int# -negateInt# a1 = (GHC.Prim.negateInt#) a1 -{-# NOINLINE addIntC# #-} -addIntC# :: Int# -> Int# -> (# Int#,Int# #) -addIntC# a1 a2 = (GHC.Prim.addIntC#) a1 a2 -{-# NOINLINE subIntC# #-} -subIntC# :: Int# -> Int# -> (# Int#,Int# #) -subIntC# a1 a2 = (GHC.Prim.subIntC#) a1 a2 -{-# NOINLINE (>#) #-} -(>#) :: Int# -> Int# -> Int# -(>#) a1 a2 = (GHC.Prim.>#) a1 a2 -{-# NOINLINE (>=#) #-} -(>=#) :: Int# -> Int# -> Int# -(>=#) a1 a2 = (GHC.Prim.>=#) a1 a2 -{-# NOINLINE (==#) #-} -(==#) :: Int# -> Int# -> Int# -(==#) a1 a2 = (GHC.Prim.==#) a1 a2 -{-# NOINLINE (/=#) #-} -(/=#) :: Int# -> Int# -> Int# -(/=#) a1 a2 = (GHC.Prim./=#) a1 a2 -{-# NOINLINE (<#) #-} -(<#) :: Int# -> Int# -> Int# -(<#) a1 a2 = (GHC.Prim.<#) a1 a2 -{-# NOINLINE (<=#) #-} -(<=#) :: Int# -> Int# -> Int# -(<=#) a1 a2 = (GHC.Prim.<=#) a1 a2 -{-# NOINLINE chr# #-} -chr# :: Int# -> Char# -chr# a1 = (GHC.Prim.chr#) a1 -{-# NOINLINE int2Word# #-} -int2Word# :: Int# -> Word# -int2Word# a1 = (GHC.Prim.int2Word#) a1 -{-# NOINLINE int2Float# #-} -int2Float# :: Int# -> Float# -int2Float# a1 = (GHC.Prim.int2Float#) a1 -{-# NOINLINE int2Double# #-} -int2Double# :: Int# -> Double# -int2Double# a1 = (GHC.Prim.int2Double#) a1 -{-# NOINLINE word2Float# #-} -word2Float# :: Word# -> Float# -word2Float# a1 = (GHC.Prim.word2Float#) a1 -{-# NOINLINE word2Double# #-} -word2Double# :: Word# -> Double# -word2Double# a1 = (GHC.Prim.word2Double#) a1 -{-# NOINLINE uncheckedIShiftL# #-} -uncheckedIShiftL# :: Int# -> Int# -> Int# -uncheckedIShiftL# a1 a2 = (GHC.Prim.uncheckedIShiftL#) a1 a2 -{-# NOINLINE uncheckedIShiftRA# #-} -uncheckedIShiftRA# :: Int# -> Int# -> Int# -uncheckedIShiftRA# a1 a2 = (GHC.Prim.uncheckedIShiftRA#) a1 a2 -{-# NOINLINE uncheckedIShiftRL# #-} -uncheckedIShiftRL# :: Int# -> Int# -> Int# -uncheckedIShiftRL# a1 a2 = (GHC.Prim.uncheckedIShiftRL#) a1 a2 {-# NOINLINE extendInt8# #-} extendInt8# :: Int8# -> Int# extendInt8# a1 = (GHC.Prim.extendInt8#) a1 @@ -292,6 +205,96 @@ {-# NOINLINE neWord16# #-} neWord16# :: Word16# -> Word16# -> Int# neWord16# a1 a2 = (GHC.Prim.neWord16#) a1 a2 +{-# NOINLINE (+#) #-} +(+#) :: Int# -> Int# -> Int# +(+#) a1 a2 = (GHC.Prim.+#) a1 a2 +{-# NOINLINE (-#) #-} +(-#) :: Int# -> Int# -> Int# +(-#) a1 a2 = (GHC.Prim.-#) a1 a2 +{-# NOINLINE (*#) #-} +(*#) :: Int# -> Int# -> Int# +(*#) a1 a2 = (GHC.Prim.*#) a1 a2 +{-# NOINLINE timesInt2# #-} +timesInt2# :: Int# -> Int# -> (# Int#,Int#,Int# #) +timesInt2# a1 a2 = (GHC.Prim.timesInt2#) a1 a2 +{-# NOINLINE mulIntMayOflo# #-} +mulIntMayOflo# :: Int# -> Int# -> Int# +mulIntMayOflo# a1 a2 = (GHC.Prim.mulIntMayOflo#) a1 a2 +{-# NOINLINE quotInt# #-} +quotInt# :: Int# -> Int# -> Int# +quotInt# a1 a2 = (GHC.Prim.quotInt#) a1 a2 +{-# NOINLINE remInt# #-} +remInt# :: Int# -> Int# -> Int# +remInt# a1 a2 = (GHC.Prim.remInt#) a1 a2 +{-# NOINLINE quotRemInt# #-} +quotRemInt# :: Int# -> Int# -> (# Int#,Int# #) +quotRemInt# a1 a2 = (GHC.Prim.quotRemInt#) a1 a2 +{-# NOINLINE andI# #-} +andI# :: Int# -> Int# -> Int# +andI# a1 a2 = (GHC.Prim.andI#) a1 a2 +{-# NOINLINE orI# #-} +orI# :: Int# -> Int# -> Int# +orI# a1 a2 = (GHC.Prim.orI#) a1 a2 +{-# NOINLINE xorI# #-} +xorI# :: Int# -> Int# -> Int# +xorI# a1 a2 = (GHC.Prim.xorI#) a1 a2 +{-# NOINLINE notI# #-} +notI# :: Int# -> Int# +notI# a1 = (GHC.Prim.notI#) a1 +{-# NOINLINE negateInt# #-} +negateInt# :: Int# -> Int# +negateInt# a1 = (GHC.Prim.negateInt#) a1 +{-# NOINLINE addIntC# #-} +addIntC# :: Int# -> Int# -> (# Int#,Int# #) +addIntC# a1 a2 = (GHC.Prim.addIntC#) a1 a2 +{-# NOINLINE subIntC# #-} +subIntC# :: Int# -> Int# -> (# Int#,Int# #) +subIntC# a1 a2 = (GHC.Prim.subIntC#) a1 a2 +{-# NOINLINE (>#) #-} +(>#) :: Int# -> Int# -> Int# +(>#) a1 a2 = (GHC.Prim.>#) a1 a2 +{-# NOINLINE (>=#) #-} +(>=#) :: Int# -> Int# -> Int# +(>=#) a1 a2 = (GHC.Prim.>=#) a1 a2 +{-# NOINLINE (==#) #-} +(==#) :: Int# -> Int# -> Int# +(==#) a1 a2 = (GHC.Prim.==#) a1 a2 +{-# NOINLINE (/=#) #-} +(/=#) :: Int# -> Int# -> Int# +(/=#) a1 a2 = (GHC.Prim./=#) a1 a2 +{-# NOINLINE (<#) #-} +(<#) :: Int# -> Int# -> Int# +(<#) a1 a2 = (GHC.Prim.<#) a1 a2 +{-# NOINLINE (<=#) #-} +(<=#) :: Int# -> Int# -> Int# +(<=#) a1 a2 = (GHC.Prim.<=#) a1 a2 +{-# NOINLINE chr# #-} +chr# :: Int# -> Char# +chr# a1 = (GHC.Prim.chr#) a1 +{-# NOINLINE int2Word# #-} +int2Word# :: Int# -> Word# +int2Word# a1 = (GHC.Prim.int2Word#) a1 +{-# NOINLINE int2Float# #-} +int2Float# :: Int# -> Float# +int2Float# a1 = (GHC.Prim.int2Float#) a1 +{-# NOINLINE int2Double# #-} +int2Double# :: Int# -> Double# +int2Double# a1 = (GHC.Prim.int2Double#) a1 +{-# NOINLINE word2Float# #-} +word2Float# :: Word# -> Float# +word2Float# a1 = (GHC.Prim.word2Float#) a1 +{-# NOINLINE word2Double# #-} +word2Double# :: Word# -> Double# +word2Double# a1 = (GHC.Prim.word2Double#) a1 +{-# NOINLINE uncheckedIShiftL# #-} +uncheckedIShiftL# :: Int# -> Int# -> Int# +uncheckedIShiftL# a1 a2 = (GHC.Prim.uncheckedIShiftL#) a1 a2 +{-# NOINLINE uncheckedIShiftRA# #-} +uncheckedIShiftRA# :: Int# -> Int# -> Int# +uncheckedIShiftRA# a1 a2 = (GHC.Prim.uncheckedIShiftRA#) a1 a2 +{-# NOINLINE uncheckedIShiftRL# #-} +uncheckedIShiftRL# :: Int# -> Int# -> Int# +uncheckedIShiftRL# a1 a2 = (GHC.Prim.uncheckedIShiftRL#) a1 a2 {-# NOINLINE plusWord# #-} plusWord# :: Word# -> Word# -> Word# plusWord# a1 a2 = (GHC.Prim.plusWord#) a1 a2 @@ -1372,6 +1375,18 @@ {-# NOINLINE writeWord64OffAddr# #-} writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s writeWord64OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord64OffAddr#) a1 a2 a3 a4 +{-# NOINLINE atomicExchangeAddrAddr# #-} +atomicExchangeAddrAddr# :: Addr# -> Addr# -> State# s -> (# State# s,Addr# #) +atomicExchangeAddrAddr# a1 a2 a3 = (GHC.Prim.atomicExchangeAddrAddr#) a1 a2 a3 +{-# NOINLINE atomicExchangeWordAddr# #-} +atomicExchangeWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #) +atomicExchangeWordAddr# a1 a2 a3 = (GHC.Prim.atomicExchangeWordAddr#) a1 a2 a3 +{-# NOINLINE atomicCasAddrAddr# #-} +atomicCasAddrAddr# :: Addr# -> Addr# -> Addr# -> State# s -> (# State# s,Addr# #) +atomicCasAddrAddr# a1 a2 a3 a4 = (GHC.Prim.atomicCasAddrAddr#) a1 a2 a3 a4 +{-# NOINLINE atomicCasWordAddr# #-} +atomicCasWordAddr# :: Addr# -> Word# -> Word# -> State# s -> (# State# s,Word# #) +atomicCasWordAddr# a1 a2 a3 a4 = (GHC.Prim.atomicCasWordAddr#) a1 a2 a3 a4 {-# NOINLINE newMutVar# #-} newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #) newMutVar# a1 a2 = (GHC.Prim.newMutVar#) a1 a2 @@ -1468,6 +1483,18 @@ {-# NOINLINE isEmptyMVar# #-} isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #) isEmptyMVar# a1 a2 = (GHC.Prim.isEmptyMVar#) a1 a2 +{-# NOINLINE newIOPort# #-} +newIOPort# :: State# s -> (# State# s,IOPort# s a #) +newIOPort# a1 = (GHC.Prim.newIOPort#) a1 +{-# NOINLINE readIOPort# #-} +readIOPort# :: IOPort# s a -> State# s -> (# State# s,a #) +readIOPort# a1 a2 = (GHC.Prim.readIOPort#) a1 a2 +{-# NOINLINE writeIOPort# #-} +writeIOPort# :: IOPort# s a -> a -> State# s -> (# State# s,Int# #) +writeIOPort# a1 a2 a3 = (GHC.Prim.writeIOPort#) a1 a2 a3 +{-# NOINLINE sameIOPort# #-} +sameIOPort# :: IOPort# s a -> IOPort# s a -> Int# +sameIOPort# a1 a2 = (GHC.Prim.sameIOPort#) a1 a2 {-# NOINLINE delay# #-} delay# :: Int# -> State# s -> State# s delay# a1 a2 = (GHC.Prim.delay#) a1 a2 @@ -1591,6 +1618,9 @@ {-# NOINLINE numSparks# #-} numSparks# :: State# s -> (# State# s,Int# #) numSparks# a1 = (GHC.Prim.numSparks#) a1 +{-# NOINLINE keepAlive# #-} +keepAlive# :: o -> State# (RealWorld) -> (State# (RealWorld) -> p) -> p +keepAlive# a1 a2 a3 = (GHC.Prim.keepAlive#) a1 a2 a3 {-# NOINLINE dataToTag# #-} dataToTag# :: a -> Int# dataToTag# a1 = (GHC.Prim.dataToTag#) a1 @@ -1601,10 +1631,10 @@ anyToAddr# :: a -> State# (RealWorld) -> (# State# (RealWorld),Addr# #) anyToAddr# a1 a2 = (GHC.Prim.anyToAddr#) a1 a2 {-# NOINLINE mkApUpd0# #-} -mkApUpd0# :: BCO# -> (# a #) +mkApUpd0# :: BCO -> (# a #) mkApUpd0# a1 = (GHC.Prim.mkApUpd0#) a1 {-# NOINLINE newBCO# #-} -newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #) +newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO #) newBCO# a1 a2 a3 a4 a5 a6 = (GHC.Prim.newBCO#) a1 a2 a3 a4 a5 a6 {-# NOINLINE unpackClosure# #-} unpackClosure# :: a -> (# Addr#,ByteArray#,Array# b #) diff --git a/GHC/Tuple.hs b/GHC/Tuple.hs --- a/GHC/Tuple.hs +++ b/GHC/Tuple.hs @@ -28,8 +28,8 @@ -- The desugarer uses 1-tuples, -- but "()" is already used up for 0-tuples --- See Note [One-tuples] in TysWiredIn -data Unit a = Unit a +-- See Note [One-tuples] in GHC.Builtin.Types +data Solo a = Solo a data (a,b) = (a,b) data (a,b,c) = (a,b,c) diff --git a/GHC/Types.hs b/GHC/Types.hs --- a/GHC/Types.hs +++ b/GHC/Types.hs @@ -1,6 +1,7 @@ {-# LANGUAGE MagicHash, NoImplicitPrelude, TypeFamilies, UnboxedTuples, MultiParamTypeClasses, RoleAnnotations, CPP, TypeOperators, - PolyKinds #-} + PolyKinds, NegativeLiterals, DataKinds #-} +-- NegativeLiterals: see Note [Fixity of (->)] ----------------------------------------------------------------------------- -- | -- Module : GHC.Types @@ -40,15 +41,42 @@ -- * Runtime type representation Module(..), TrName(..), TyCon(..), TypeLitSort(..), - KindRep(..), KindBndr + KindRep(..), KindBndr, + + -- * Multiplicity Types + Multiplicity(..), MultMul ) where import GHC.Prim infixr 5 : + {- ********************************************************************* * * + Functions +* * +********************************************************************* -} + +infixr -1 -> +{- +Note [Fixity of (->)] +~~~~~~~~~~~~~~~~~~~~~ +This declaration is important for :info (->) command (issue #10145) +1) The parser parses -> as if it had lower fixity than 0, + so we conventionally use -1 (issue #15235). +2) Fixities outside the 0-9 range are exceptionally allowed + for (->) (see checkPrecP in RdrHsSyn) +3) The negative fixity -1 must be parsed as a single token, + hence this module requires NegativeLiterals. +-} + +-- | The regular function type +type (->) = FUN 'Many +-- See Note [Linear Types] in Multiplicity + +{- ********************************************************************* +* * Kinds * * ********************************************************************* -} @@ -59,6 +87,14 @@ -- | The kind of types with lifted values. For example @Int :: Type@. type Type = TYPE 'LiftedRep +data Multiplicity = Many | One + +type family MultMul (a :: Multiplicity) (b :: Multiplicity) :: Multiplicity where + MultMul 'One x = x + MultMul x 'One = x + MultMul 'Many x = 'Many + MultMul x 'Many = 'Many + {- ********************************************************************* * * Nat and Symbol @@ -84,7 +120,7 @@ -- to @x@. -- type family Any :: k where { } --- See Note [Any types] in TysWiredIn. Also, for a bit of history on Any see +-- See Note [Any types] in GHC.Builtin.Types. Also, for a bit of history on Any see -- #10886. Note that this must be a *closed* type family: we need to ensure -- that this can't reduce to a `data` type for the results discussed in -- Note [Any types]. @@ -185,15 +221,8 @@ class. -} newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #)) -type role IO representational -{- The 'type role' role annotation for IO is redundant but is included -because this role is significant in the normalisation of FFI -types. Specifically, if this role were to become nominal (which would -be very strange, indeed!), changes elsewhere in GHC would be -necessary. See [FFI type roles] in TcForeign. -} - {- ********************************************************************* * * (~) and Coercible @@ -214,7 +243,7 @@ Furthermore the type of MkCoercible cannot be written in Haskell (no syntax for ~#R). -So we define them as regular data types in GHC.Types, and do magic in TysWiredIn, +So we define them as regular data types in GHC.Types, and do magic in GHC.Builtin.Types, inside GHC, to change the kind and type. -} @@ -226,15 +255,22 @@ -- about the difference between heterogeneous equality @~~@ and -- homogeneous equality @~@, this is printed as @~@ unless -- @-fprint-equality-relations@ is set. +-- +-- In @0.7.0@, the fixity was set to @infix 4@ to match the fixity of 'Data.Type.Equality.:~~:'. class a ~~ b - -- See also Note [The equality types story] in TysPrim + -- See also Note [The equality types story] in GHC.Builtin.Types.Prim + -- | Lifted, homogeneous equality. By lifted, we mean that it -- can be bogus (deferred type error). By homogeneous, the two -- types @a@ and @b@ must have the same kinds. + +-- In @0.7.0@, the fixity was set to @infix 4@ to match the fixity of 'Data.Type.Equality.:~:'. class a ~ b - -- See also Note [The equality types story] in TysPrim +infix 4 ~, ~~ + -- See also Note [The equality types story] in GHC.Builtin.Types.Prim + -- | @Coercible@ is a two-parameter class that has instances for types @a@ and @b@ if -- the compiler can infer that they have the same representation. This class -- does not have regular instances; instead they are created on-the-fly during @@ -283,7 +319,7 @@ -- -- @since 4.7.0.0 class Coercible (a :: k) (b :: k) - -- See also Note [The equality types story] in TysPrim + -- See also Note [The equality types story] in GHC.Builtin.Types.Prim {- ********************************************************************* * * @@ -409,7 +445,7 @@ -- RuntimeRep is intimately tied to TyCon.RuntimeRep (in GHC proper). See -- Note [RuntimeRep and PrimRep] in RepType. --- See also Note [Wiring in RuntimeRep] in TysWiredIn +-- See also Note [Wiring in RuntimeRep] in GHC.Builtin.Types -- | Length of a SIMD vector type data VecCount = Vec2 @@ -459,12 +495,12 @@ #include "MachDeps.h" data Module = Module - TrName -- Package name - TrName -- Module name + TrName -- ^ Package name + TrName -- ^ Module name data TrName - = TrNameS Addr# -- Static - | TrNameD [Char] -- Dynamic + = TrNameS Addr# -- ^ Static + | TrNameD [Char] -- ^ Dynamic -- | A de Bruijn index for a binder within a 'KindRep'. type KindBndr = Int @@ -478,7 +514,7 @@ -- | The representation produced by GHC for conjuring up the kind of a -- 'Data.Typeable.TypeRep'. --- See Note [Representing TyCon kinds: KindRep] in TcTypeable. +-- See Note [Representing TyCon kinds: KindRep] in GHC.Tc.Instance.Typeable. data KindRep = KindRepTyConApp TyCon [KindRep] | KindRepVar !KindBndr | KindRepApp KindRep KindRep @@ -491,8 +527,9 @@ | TypeLitNat -- Show instance for TyCon found in GHC.Show -data TyCon = TyCon WORD64_TY WORD64_TY -- Fingerprint - Module -- Module in which this is defined - TrName -- Type constructor name - Int# -- How many kind variables do we accept? - KindRep -- A representation of the type's kind +data TyCon = TyCon WORD64_TY -- ^ Fingerprint (high) + WORD64_TY -- ^ Fingerprint (low) + Module -- ^ Module in which this is defined + TrName -- ^ Type constructor name + Int# -- ^ How many kind variables do we accept? + KindRep -- ^ A representation of the type's kind diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,88 @@ + +-- We need to do some ugly hacks here because of GHC magic + +module Main (main) where + +import Control.Monad +import Data.List +import Data.Maybe +import Distribution.PackageDescription +import Distribution.Simple +import Distribution.Simple.LocalBuildInfo +import Distribution.Simple.Program +import Distribution.Simple.Utils +import Distribution.Text +import System.Cmd +import System.FilePath +import System.Exit +import System.Directory + +main :: IO () +main = do let hooks = simpleUserHooks { + regHook = addPrimModule + $ regHook simpleUserHooks, + buildHook = build_primitive_sources + $ buildHook simpleUserHooks, + haddockHook = addPrimModuleForHaddock + $ build_primitive_sources + $ haddockHook simpleUserHooks } + defaultMainWithHooks hooks + +type Hook a = PackageDescription -> LocalBuildInfo -> UserHooks -> a -> IO () + +addPrimModule :: Hook a -> Hook a +addPrimModule f pd lbi uhs x = + do let -- I'm not sure which one of these we actually need to change. + -- It seems bad that there are two. + pd' = addPrimModuleToPD pd + lpd = addPrimModuleToPD (localPkgDescr lbi) + lbi' = lbi { localPkgDescr = lpd } + f pd' lbi' uhs x + +addPrimModuleForHaddock :: Hook a -> Hook a +addPrimModuleForHaddock f pd lbi uhs x = + do let pc = withPrograms lbi + pc' = userSpecifyArgs "haddock" ["GHC/Prim.hs"] pc + lbi' = lbi { withPrograms = pc' } + f pd lbi' uhs x + +addPrimModuleToPD :: PackageDescription -> PackageDescription +addPrimModuleToPD pd = + case library pd of + Just lib -> + let ems = fromJust (simpleParse "GHC.Prim") : exposedModules lib + lib' = lib { exposedModules = ems } + in pd { library = Just lib' } + Nothing -> + error "Expected a library, but none found" + +build_primitive_sources :: Hook a -> Hook a +build_primitive_sources f pd lbi uhs x + = do when (compilerFlavor (compiler lbi) == GHC) $ do + let genprimopcode = joinPath ["..", "..", "utils", + "genprimopcode", "genprimopcode"] + primops = joinPath ["..", "..", "compiler", "prelude", + "primops.txt"] + primhs = joinPath ["GHC", "Prim.hs"] + primopwrappers = joinPath ["GHC", "PrimopWrappers.hs"] + primhs_tmp = addExtension primhs "tmp" + primopwrappers_tmp = addExtension primopwrappers "tmp" + maybeExit $ system (genprimopcode ++ " --make-haskell-source < " + ++ primops ++ " > " ++ primhs_tmp) + maybeUpdateFile primhs_tmp primhs + maybeExit $ system (genprimopcode ++ " --make-haskell-wrappers < " + ++ primops ++ " > " ++ primopwrappers_tmp) + maybeUpdateFile primopwrappers_tmp primopwrappers + f pd lbi uhs x + +-- Replace a file only if the new version is different from the old. +-- This prevents make from doing unnecessary work after we run 'setup makefile' +maybeUpdateFile :: FilePath -> FilePath -> IO () +maybeUpdateFile source target = do + r <- rawSystem "cmp" ["-s" {-quiet-}, source, target] + case r of + ExitSuccess -> removeFile source + ExitFailure _ -> do exists <- doesFileExist target + when exists $ removeFile target + renameFile source target + diff --git a/cbits/atomic.c b/cbits/atomic.c --- a/cbits/atomic.c +++ b/cbits/atomic.c @@ -318,8 +318,41 @@ } #endif +// Atomic exchange operations + +extern StgWord hs_xchg8(StgWord x, StgWord val); +StgWord +hs_xchg8(StgWord x, StgWord val) +{ + return (StgWord) __atomic_exchange_n((StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST); +} + +extern StgWord hs_xchg16(StgWord x, StgWord val); +StgWord +hs_xchg16(StgWord x, StgWord val) +{ + return (StgWord) __atomic_exchange_n((StgWord16 *)x, (StgWord16) val, __ATOMIC_SEQ_CST); +} + +extern StgWord hs_xchg32(StgWord x, StgWord val); +StgWord +hs_xchg32(StgWord x, StgWord val) +{ + return (StgWord) __atomic_exchange_n((StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST); +} + +#if WORD_SIZE_IN_BITS == 64 +//GCC provides this even on 32bit, but StgWord is still 32 bits. +extern StgWord hs_xchg64(StgWord x, StgWord val); +StgWord +hs_xchg64(StgWord x, StgWord val) +{ + return (StgWord) __atomic_exchange_n((StgWord64 *) x, (StgWord64) val, __ATOMIC_SEQ_CST); +} +#endif + // AtomicReadByteArrayOp_Int -// Implies a full memory barrier (see compiler/prelude/primops.txt.pp) +// Implies a full memory barrier (see compiler/GHC/Builtin/primops.txt.pp) // __ATOMIC_SEQ_CST: Full barrier in both directions (hoisting and sinking // of code) and synchronizes with acquire loads and release stores in // all threads. @@ -361,6 +394,7 @@ #endif } +#if WORD_SIZE_IN_BITS == 64 extern StgWord64 hs_atomicread64(StgWord x); StgWord64 hs_atomicread64(StgWord x) @@ -371,9 +405,10 @@ return __sync_add_and_fetch((StgWord64 *) x, 0); #endif } +#endif // AtomicWriteByteArrayOp_Int -// Implies a full memory barrier (see compiler/prelude/primops.txt.pp) +// Implies a full memory barrier (see compiler/GHC/Builtin/primops.txt.pp) // __ATOMIC_SEQ_CST: Full barrier (see hs_atomicread8 above). extern void hs_atomicwrite8(StgWord x, StgWord val); @@ -409,6 +444,7 @@ #endif } +#if WORD_SIZE_IN_BITS == 64 extern void hs_atomicwrite64(StgWord x, StgWord64 val); void hs_atomicwrite64(StgWord x, StgWord64 val) @@ -419,4 +455,6 @@ while (!__sync_bool_compare_and_swap((StgWord64 *) x, *(StgWord64 *) x, (StgWord64) val)); #endif } +#endif + #endif diff --git a/cbits/ctz.c b/cbits/ctz.c --- a/cbits/ctz.c +++ b/cbits/ctz.c @@ -32,7 +32,7 @@ hs_ctz64(StgWord64 x) { #if defined(__GNUC__) && (defined(i386_HOST_ARCH) || defined(powerpc_HOST_ARCH)) - /* On Linux/i386, the 64bit `__builtin_ctzll()` instrinsic doesn't + /* On Linux/i386, the 64bit `__builtin_ctzll()` intrinsic doesn't get inlined by GCC but rather a short `__ctzdi2` runtime function is inserted when needed into compiled object files. diff --git a/changelog.md b/changelog.md --- a/changelog.md +++ b/changelog.md @@ -1,5 +1,44 @@ -## 0.6.1 +## 0.7.0 (*Jan 2021*) +- Shipped with GHC 9.0.1 + +- Add known-key `cstringLength#` to `GHC.CString`. This is just the + C function `strlen`, but a built-in rewrite rule allows GHC to + compute the result at compile time when the argument is known. + +- In order to support unicode better the following functions in `GHC.CString` + gained UTF8 counterparts: + + unpackAppendCStringUtf8# :: Addr# -> [Char] -> [Char] + unpackFoldrCStringUtf8# :: Addr# -> (Char -> a -> a) -> a -> a + +- `unpackFoldrCString*` variants can now inline in phase `[0]`. + + If the folding function is known this allows for unboxing of the + Char argument resulting in much faster code. + +- Renamed the singleton tuple `GHC.Tuple.Unit` to `GHC.Tuple.Solo`. + +- Add primops for atomic exchange: + + atomicExchangeAddrAddr# :: Addr# -> Addr# -> State# s -> (# State# s, Addr# #) + atomicExchangeWordAddr# :: Addr# -> Word# -> State# s -> (# State# s, Word# #) + +- Add primops for atomic compare and swap at a given `Addr#`: + + atomicCasAddrAddr# :: Addr# -> Addr# -> Addr# -> State# s -> (# State# s, Addr# #) + atomicCasWordAddr# :: Addr# -> Word# -> Word# -> State# s -> (# State# s, Word# #) + +- Add an explicit fixity for `(~)` and `(~~)`: + + infix 4 ~, ~~ + +- Introduce `keepAlive#` to replace `touch#` in controlling object lifetime without + the soundness issues of the latter (see + [#17760](https://gitlab.haskell.org/ghc/ghc/-/issues/17760)). + +## 0.6.1 (*March 2020*) + - Shipped with GHC 8.10.1 - Add primop for shrinking `SmallMutableArray#` @@ -26,6 +65,16 @@ `bitReverse#` is a primop that, for a `Word` of 8, 16, 32 or 64 bits, reverses the order of its bits e.g. `0b110001` becomes `0b100011`. These primitives use optimized machine instructions when available. + +- Add Int# multiplication primop: + + timesInt2# :: Int# -> Int# -> (# Int#, Int#, Int# #) + + `timesInt2#` computes the multiplication of its two parameters and returns a + triple (isHighNeeded,high,low) where high and low are respectively the high + and low bits of the double-word result. isHighNeeded is a cheap way to test + if the high word is a sign-extension of the low word (isHighNeeded = 0#) or + not (isHighNeeded = 1#). ## 0.6.0 diff --git a/ghc-prim.cabal b/ghc-prim.cabal --- a/ghc-prim.cabal +++ b/ghc-prim.cabal @@ -1,7 +1,6 @@ cabal-version: 2.2 name: ghc-prim -version: 0.6.1 - +version: 0.7.0 -- NOTE: Don't forget to update ./changelog.md license: BSD-3-Clause license-file: LICENSE @@ -9,7 +8,7 @@ maintainer: libraries@haskell.org bug-reports: https://gitlab.haskell.org/ghc/ghc/issues/new synopsis: GHC primitives -build-type: Simple +build-type: Custom description: This package contains the primitive types and operations supplied by GHC. @@ -20,6 +19,9 @@ location: https://gitlab.haskell.org/ghc/ghc.git subdir: libraries/ghc-prim +custom-setup + setup-depends: base >= 4 && < 5, Cabal >= 1.23 + Library default-language: Haskell2010 other-extensions: @@ -43,8 +45,9 @@ GHC.Debug GHC.IntWord64 GHC.Magic - GHC.Prim GHC.Prim.Ext + GHC.Prim.Panic + GHC.Prim.Exception GHC.PrimopWrappers GHC.Tuple GHC.Types @@ -65,6 +68,11 @@ -- user32: provides access to apis to modify user components (UI etc) -- on Windows. Required because of mingw32. extra-libraries: user32, mingw32, mingwex + + if os(linux) + -- we need libm, but for musl and other's we might need libc, as libm + -- is just an empty shell. + extra-libraries: c, m c-sources: cbits/atomic.c