Problem building on sparc/Linux

Simon Marlow simonmarhaskell at gmail.com
Wed Mar 1 07:24:17 EST 2006


Ian Lynagh wrote:
> I'm having problems building ghc 6.4.1 with ghc 6.4.1 (should be
> unregisterised in both cases) on Sparc/Linux:
> 
> mkdir stage1/cprAnalysis
> mkdir stage1/compMan
> mkdir stage1/ndpFlatten
> mkdir stage1/iface
> mkdir stage1/cmm
> mkdir stage1/ghci 
> Creating main/Config.hs ...
> done.
> Creating stage1/ghc_boot_platform.h...
> Done.
> gcc -E  -undef -traditional -P -I../includes    -x c prelude/primops.txt.pp | \
>         grep -v '^#pragma GCC' > prelude/primops.txt
> ../utils/genprimopcode/genprimopcode --data-decl          < prelude/primops.txt > primop-data-decl.hs-incl
> genprimopcode: parse error at (line 579, column 1):
> unexpected "\t"
> expecting "primop", "section" or "thats_all_folks"
> make[3]: *** [primop-data-decl.hs-incl] Error 1
> make[3]: *** Deleting file `primop-data-decl.hs-incl'
> make[2]: *** [boot] Error 1
> make[2]: Leaving directory `/scratch/igloo/test_rebuild/ghc6-6.4.1/ghc'
> make[1]: *** [build] Error 1
> make[1]: Leaving directory `/scratch/igloo/test_rebuild/ghc6-6.4.1'
> make: *** [build-stamp] Error 2

There's a ticket open on this one:

   http://cvs.haskell.org/trac/ghc/ticket/470

The ticket does give more info (isSpace isn't working correctly).  If 
you could track this down further, that would be great.

I have a vague hunch that this might be related to one of these:

   * [project @ 2006-01-10 14:46:50 by simonmar]
   Char primops: the Char# rep is wordRep, not I32 (fixed -dcmm-lint
   problems on x86_64)

     M ./ghc/compiler/codeGen/CgPrimOp.hs -6 +6

   * [project @ 2006-01-09 10:31:14 by simonmar]
   ord# and chr# should be no-ops, not conversions between wordRep and I32.

     M ./ghc/compiler/codeGen/CgPrimOp.hs -3 +2

It seems a bit unlikely though.

Both of these were merged post-6.4.1.

Cheers,
	Simon







> 
> 
> igloo at vore:/scratch/igloo/test_rebuild/ghc6-6.4.1$ ghc --version
> The Glorious Glasgow Haskell Compilation System, version 6.4.1
> 
> igloo at vore:/scratch/igloo/test_rebuild/ghc6-6.4.1$ gcc --version
> gcc (GCC) 3.3.6 (Debian 1:3.3.6-12)
> Copyright (C) 2003 Free Software Foundation, Inc.
> This is free software; see the source for copying conditions.  There is NO
> warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
> 
> 
> I have attached
> vore:/scratch/igloo/test_rebuild/ghc6-6.4.1/ghc/compiler/prelude/primops.txt
> 
> Anyone got any idea what's going on?
> 
> 
> Thanks
> Ian
> 
> 
> 
> ------------------------------------------------------------------------
> 
> -----------------------------------------------------------------------
> -- $Id: primops.txt.pp,v 1.32.2.3 2005/03/07 15:20:14 simonmar Exp $
> --
> -- Primitive Operations
> --
> -----------------------------------------------------------------------
> 
> -- This file is processed by the utility program genprimopcode to produce
> -- a number of include files within the compiler and optionally to produce
> -- human-readable documentation.
> --
> -- It should first be preprocessed.
> --
> -- To add a new primop, you currently need to update the following files:
> --
> --	- this file (ghc/compiler/prelude/primops.txt.pp), which includes
> --	  the type of the primop, and various other properties (its
> --	  strictness attributes, whether it is defined as a macro
> --	  or as out-of-line code, etc.)
> --
> --	- if the primop is inline (i.e. a macro), then:
> --	  	ghc/compiler/AbsCUtils.lhs (dscCOpStmt)
> --		  defines the translation of the primop into simpler
> --		  abstract C operations.
> --		
> --	- or, for an out-of-line primop:
> --	        ghc/includes/PrimOps.h (just add the declaration)
> --		ghc/rts/PrimOps.hc     (define it here)
> --		ghc/rts/Linker.c       (declare the symbol for GHCi)
> --
> --	- the User's Guide 
> --
> 
> -- This file is divided into named sections, each containing or more
> -- primop entries. Section headers have the format:
> --
> --	section "section-name" {description}
> --
> -- This information is used solely when producing documentation; it is
> -- otherwise ignored.  The description is optional.
> --
> -- The format of each primop entry is as follows:
> --
> --	primop internal-name "name-in-program-text" type category {description} attributes
> 
> -- The default attribute values which apply if you don't specify
> -- other ones.  Attribute values can be True, False, or arbitrary
> -- text between curly brackets.  This is a kludge to enable 
> -- processors of this file to easily get hold of simple info
> -- (eg, out_of_line), whilst avoiding parsing complex expressions
> -- needed for strictness and usage info.
> 
> defaults
>    has_side_effects = False
>    out_of_line      = False
>    commutable       = False
>    needs_wrapper    = False
>    can_fail         = False
>    strictness       = { \ arity -> mkStrictSig (mkTopDmdType (replicate arity lazyDmd) TopRes) }
>    usage            = { nomangle other }
> 
> -- Currently, documentation is produced using latex, so contents of
> -- description fields should be legal latex. Descriptions can contain
> -- matched pairs of embedded curly brackets.
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> -- We need platform defines (tests for mingw32 below).  However, we only
> -- test the TARGET platform, which doesn't vary between stages, so the
> -- stage1 platform defines are fine:
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> section "The word size story."
> 	{Haskell98 specifies that signed integers (type {\tt Int})
> 	 must contain at least 30 bits. GHC always implements {\tt
> 	 Int} using the primitive type {\tt Int\#}, whose size equals
> 	 the {\tt MachDeps.h} constant {\tt WORD\_SIZE\_IN\_BITS}.
> 	 This is normally set based on the {\tt config.h} parameter
> 	 {\tt 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, e.g., 31 bits, to allow the
> 	 possibility of using tag bits. Currently GHC itself has only
> 	 32-bit and 64-bit variants, but 30 or 31-bit code can be
> 	 exported as an external core file for use in other back ends.
> 
> 	 GHC also implements a primitive unsigned integer type {\tt
> 	 Word\#} which always has the same number of bits as {\tt
> 	 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 {\tt Int\#} and {\tt Word\#}, and the
> 	 operations implemented in terms of the the primops on these
> 	 types, with suitable range restrictions on the results (using
> 	 the {\tt narrow$n$Int\#} and {\tt narrow$n$Word\#} families
> 	 of primops.  The 32-bit sizes are represented using {\tt
> 	 Int\#} and {\tt Word\#} when {\tt WORD\_SIZE\_IN\_BITS}
> 	 $\geq$ 32; otherwise, these are represented using distinct
> 	 primitive types {\tt Int32\#} and {\tt 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 {\tt PrelInt} and {\tt PrelWord} modules, which use
> 	 {\tt \#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 {\it types} vary according to
> 	 the value of {\tt WORD\_SIZE\_IN\_BITS}. For example, if word
> 	 size is at least 32 bits then an operator like
> 	 \texttt{indexInt32Array\#} has type {\tt ByteArr\# -> Int\#
> 	 -> Int\#}; otherwise it has type {\tt ByteArr\# -> Int\# ->
> 	 Int32\#}.  This approach confines the necessary {\tt
> 	 \#if}-defs to this file; no conditional compilation is needed
> 	 in the files that expose these primops, namely
> 	 \texttt{lib/std/PrelStorable.lhs},
> 	 \texttt{hslibs/lang/ArrayBase.hs}, and (in deprecated
> 	 fashion) in \texttt{hslibs/lang/ForeignObj.lhs} and
> 	 \texttt{hslibs/lang/Addr.lhs}.
> 
> 	 Finally, there are strongly deprecated primops for coercing
>          between {\tt Addr\#}, the primitive type of machine
>          addresses, and {\tt 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 {\tt Int\#},
>          so are not available in this case.  }
> 	
> -- Define synonyms for indexing ops. 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> 
> ------------------------------------------------------------------------
> section "Char#" 
> 	{Operations on 31-bit characters.}
> ------------------------------------------------------------------------
> 
> 
> primop   CharGtOp  "gtChar#"   Compare   Char# -> Char# -> Bool
> primop   CharGeOp  "geChar#"   Compare   Char# -> Char# -> Bool
> 
> primop   CharEqOp  "eqChar#"   Compare
>    Char# -> Char# -> Bool
>    with commutable = True
> 
> primop   CharNeOp  "neChar#"   Compare
>    Char# -> Char# -> Bool
>    with commutable = True
> 
> primop   CharLtOp  "ltChar#"   Compare   Char# -> Char# -> Bool
> primop   CharLeOp  "leChar#"   Compare   Char# -> Char# -> Bool
> 
> primop   OrdOp   "ord#"  GenPrimOp   Char# -> Int#
> 
> ------------------------------------------------------------------------
> section "Int#"
> 	{Operations on native-size integers (30+ bits).}
> ------------------------------------------------------------------------
> 
> primop   IntAddOp    "+#"    Dyadic
>    Int# -> Int# -> Int#
>    with commutable = True
> 
> primop   IntSubOp    "-#"    Dyadic   Int# -> Int# -> Int#
> 
> primop   IntMulOp    "*#" 
>    Dyadic   Int# -> Int# -> Int#
>    {Low word of signed integer multiply.}
>    with commutable = True
> 
> primop   IntMulMayOfloOp  "mulIntMayOflo#" 
>    Dyadic   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 recommmended 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.
>    }
>    with commutable = True
> 
> primop   IntQuotOp    "quotInt#"    Dyadic
>    Int# -> Int# -> Int#
>    {Rounds towards zero.}
>    with can_fail = True
> 
> primop   IntRemOp    "remInt#"    Dyadic
>    Int# -> Int# -> Int#
>    {Satisfies \texttt{(quotInt\# x y) *\# y +\# (remInt\# x y) == x}.}
>    with can_fail = True
> 
> primop   IntGcdOp    "gcdInt#"    Dyadic   Int# -> Int# -> Int#
>    with out_of_line = True
> 
> primop   IntNegOp    "negateInt#"    Monadic   Int# -> Int#
> primop   IntAddCOp   "addIntC#"    GenPrimOp   Int# -> Int# -> (# Int#, Int# #)
> 	 {Add with carry.  First member of result is (wrapped) sum; 
>           second member is 0 iff no overflow occured.}
> primop   IntSubCOp   "subIntC#"    GenPrimOp   Int# -> Int# -> (# Int#, Int# #)
> 	 {Subtract with carry.  First member of result is (wrapped) difference; 
>           second member is 0 iff no overflow occured.}
> 
> primop   IntGtOp  ">#"   Compare   Int# -> Int# -> Bool
> primop   IntGeOp  ">=#"   Compare   Int# -> Int# -> Bool
> 
> primop   IntEqOp  "==#"   Compare
>    Int# -> Int# -> Bool
>    with commutable = True
> 
> primop   IntNeOp  "/=#"   Compare
>    Int# -> Int# -> Bool
>    with commutable = True
> 
> primop   IntLtOp  "<#"   Compare   Int# -> Int# -> Bool
> primop   IntLeOp  "<=#"   Compare   Int# -> Int# -> Bool
> 
> primop   ChrOp   "chr#"   GenPrimOp   Int# -> Char#
> 
> primop   Int2WordOp "int2Word#" GenPrimOp Int# -> Word#
> primop   Int2FloatOp   "int2Float#"      GenPrimOp  Int# -> Float#
> primop   Int2DoubleOp   "int2Double#"          GenPrimOp  Int# -> Double#
> 
> primop   Int2IntegerOp    "int2Integer#"
>    GenPrimOp Int# -> (# Int#, ByteArr# #)
>    with out_of_line = True
> 
> primop   ISllOp   "uncheckedIShiftL#" GenPrimOp  Int# -> Int# -> Int#
> 	 {Shift left.  Result undefined if shift amount is not
>           in the range 0 to word size - 1 inclusive.}
> primop   ISraOp   "uncheckedIShiftRA#" GenPrimOp Int# -> Int# -> Int#
> 	 {Shift right arithmetic.  Result undefined if shift amount is not
>           in the range 0 to word size - 1 inclusive.}
> primop   ISrlOp   "uncheckedIShiftRL#" GenPrimOp Int# -> Int# -> Int#
> 	 {Shift right logical.  Result undefined if shift amount is not
>           in the range 0 to word size - 1 inclusive.}
> 
> ------------------------------------------------------------------------
> section "Word#"
> 	{Operations on native-sized unsigned words (30+ bits).}
> ------------------------------------------------------------------------
> 
> primop   WordAddOp   "plusWord#"   Dyadic   Word# -> Word# -> Word#
>    with commutable = True
> 
> primop   WordSubOp   "minusWord#"   Dyadic   Word# -> Word# -> Word#
> 
> primop   WordMulOp   "timesWord#"   Dyadic   Word# -> Word# -> Word#
>    with commutable = True
> 
> primop   WordQuotOp   "quotWord#"   Dyadic   Word# -> Word# -> Word#
>    with can_fail = True
> 
> primop   WordRemOp   "remWord#"   Dyadic   Word# -> Word# -> Word#
>    with can_fail = True
> 
> primop   AndOp   "and#"   Dyadic   Word# -> Word# -> Word#
>    with commutable = True
> 
> primop   OrOp   "or#"   Dyadic   Word# -> Word# -> Word#
>    with commutable = True
> 
> primop   XorOp   "xor#"   Dyadic   Word# -> Word# -> Word#
>    with commutable = True
> 
> primop   NotOp   "not#"   Monadic   Word# -> Word#
> 
> primop   SllOp   "uncheckedShiftL#"   GenPrimOp   Word# -> Int# -> Word#
> 	 {Shift left logical.   Result undefined if shift amount is not
>           in the range 0 to word size - 1 inclusive.}
> primop   SrlOp   "uncheckedShiftRL#"   GenPrimOp   Word# -> Int# -> Word#
> 	 {Shift right logical.   Result undefined if shift  amount is not
>           in the range 0 to word size - 1 inclusive.}
> 
> primop   Word2IntOp   "word2Int#"   GenPrimOp   Word# -> Int#
> 
> primop   Word2IntegerOp   "word2Integer#"   GenPrimOp 
>    Word# -> (# Int#, ByteArr# #)
>    with out_of_line = True
> 
> primop   WordGtOp   "gtWord#"   Compare   Word# -> Word# -> Bool
> primop   WordGeOp   "geWord#"   Compare   Word# -> Word# -> Bool
> primop   WordEqOp   "eqWord#"   Compare   Word# -> Word# -> Bool
> primop   WordNeOp   "neWord#"   Compare   Word# -> Word# -> Bool
> primop   WordLtOp   "ltWord#"   Compare   Word# -> Word# -> Bool
> primop   WordLeOp   "leWord#"   Compare   Word# -> Word# -> Bool
> 
> ------------------------------------------------------------------------
> section "Narrowings" 
> 	{Explicit narrowing of native-sized ints or words.}
> ------------------------------------------------------------------------
> 
> primop   Narrow8IntOp      "narrow8Int#"      Monadic   Int# -> Int#
> primop   Narrow16IntOp     "narrow16Int#"     Monadic   Int# -> Int#
> primop   Narrow32IntOp     "narrow32Int#"     Monadic   Int# -> Int#
> primop   Narrow8WordOp     "narrow8Word#"     Monadic   Word# -> Word#
> primop   Narrow16WordOp    "narrow16Word#"    Monadic   Word# -> Word#
> primop   Narrow32WordOp    "narrow32Word#"    Monadic   Word# -> Word#
> 
> 
> 
> 
> 
> ------------------------------------------------------------------------
> section "Int64#"
> 	{Operations on 64-bit unsigned words. This type is only used 
> 	 if plain Int\# has less than 64 bits. In any case, the operations
> 	 are not primops; they are implemented (if needed) as ccalls instead.}
> ------------------------------------------------------------------------
> 
> primop   Int64ToIntegerOp   "int64ToInteger#" GenPrimOp 
>    Int64# -> (# Int#, ByteArr# #)
>    with out_of_line = True
> 
> ------------------------------------------------------------------------
> section "Word64#"
> 	{Operations on 64-bit unsigned words. This type is only used 
> 	 if plain Word\# has less than 64 bits. In any case, the operations
> 	 are not primops; they are implemented (if needed) as ccalls instead.}
> ------------------------------------------------------------------------
> 
> primop   Word64ToIntegerOp   "word64ToInteger#" GenPrimOp
>    Word64# -> (# Int#, ByteArr# #)
>    with out_of_line = True
> 
> 
> 
> ------------------------------------------------------------------------
> section "Integer#"
> 	{Operations on arbitrary-precision integers. These operations are 
> implemented via the GMP package. An integer is represented as a pair
> consisting of an Int\# representing the number of 'limbs' in use and
> the sign, and a ByteArr\# containing the 'limbs' themselves.  Such pairs
> are returned as unboxed pairs, but must be passed as separate
> components.
> 
> For .NET these operations are implemented by foreign imports, so the
> primops are omitted.}
> ------------------------------------------------------------------------
> 
> 
> 
> primop   IntegerAddOp   "plusInteger#" GenPrimOp   
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #)
>    with commutable = True
>         out_of_line = True
> 
> primop   IntegerSubOp   "minusInteger#" GenPrimOp  
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #)
>    with out_of_line = True
> 
> primop   IntegerMulOp   "timesInteger#" GenPrimOp   
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #)
>    with commutable = True
>         out_of_line = True
> 
> primop   IntegerGcdOp   "gcdInteger#" GenPrimOp    
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #)
>    {Greatest common divisor.}
>    with commutable = True
>         out_of_line = True
> 
> primop   IntegerIntGcdOp   "gcdIntegerInt#" GenPrimOp
>    Int# -> ByteArr# -> Int# -> Int#
>    {Greatest common divisor, where second argument is an ordinary Int\#.}
>    with out_of_line = True
> 
> primop   IntegerDivExactOp   "divExactInteger#" GenPrimOp
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #)
>    {Divisor is guaranteed to be a factor of dividend.}
>    with out_of_line = True
> 
> primop   IntegerQuotOp   "quotInteger#" GenPrimOp
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #)
>    {Rounds towards zero.}
>    with out_of_line = True
> 
> primop   IntegerRemOp   "remInteger#" GenPrimOp
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #)
>    {Satisfies \texttt{plusInteger\# (timesInteger\# (quotInteger\# x y) y) (remInteger\# x y) == x}.}
>    with out_of_line = True
> 
> primop   IntegerCmpOp   "cmpInteger#"   GenPrimOp  
>    Int# -> ByteArr# -> Int# -> ByteArr# -> Int#
>    {Returns -1,0,1 according as first argument is less than, equal to, or greater than second argument.}
>    with needs_wrapper = True
>         out_of_line = True
> 
> primop   IntegerCmpIntOp   "cmpIntegerInt#" GenPrimOp
>    Int# -> ByteArr# -> Int# -> Int#
>    {Returns -1,0,1 according as first argument is less than, equal to, or greater than second argument, which
>    is an ordinary Int\#.}
>    with needs_wrapper = True
>         out_of_line = True
> 
> primop   IntegerQuotRemOp   "quotRemInteger#" GenPrimOp
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr#, Int#, ByteArr# #)
>    {Compute quot and rem simulaneously.}
>    with can_fail = True
>         out_of_line = True
> 
> primop   IntegerDivModOp    "divModInteger#"  GenPrimOp
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr#, Int#, ByteArr# #)
>    {Compute div and mod simultaneously, where div rounds towards negative infinity
>     and\texttt{(q,r) = divModInteger\#(x,y)} implies \texttt{plusInteger\# (timesInteger\# q y) r = x}.}
>    with can_fail = True
>         out_of_line = True
> 
> primop   Integer2IntOp   "integer2Int#"    GenPrimOp
>    Int# -> ByteArr# -> Int#
>    with needs_wrapper = True
>         out_of_line = True
> 
> primop   Integer2WordOp   "integer2Word#"   GenPrimOp
>    Int# -> ByteArr# -> Word#
>    with needs_wrapper = True
>         out_of_line = True
> 
> 
> 
> 
> 
> 
> 
> 
> 
> primop   IntegerAndOp  "andInteger#" GenPrimOp
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #)
>    with out_of_line = True
> 
> primop   IntegerOrOp  "orInteger#" GenPrimOp
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #)
>    with out_of_line = True
> 
> primop   IntegerXorOp  "xorInteger#" GenPrimOp
>    Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #)
>    with out_of_line = True
> 
> primop   IntegerComplementOp  "complementInteger#" GenPrimOp
>    Int# -> ByteArr# -> (# Int#, ByteArr# #)
>    with out_of_line = True
> 
> 
> 
> ------------------------------------------------------------------------
> section "Double#"
> 	{Operations on double-precision (64 bit) floating-point numbers.}
> ------------------------------------------------------------------------
> 
> primop   DoubleGtOp ">##"   Compare   Double# -> Double# -> Bool
> primop   DoubleGeOp ">=##"   Compare   Double# -> Double# -> Bool
> 
> primop DoubleEqOp "==##"   Compare
>    Double# -> Double# -> Bool
>    with commutable = True
> 
> primop DoubleNeOp "/=##"   Compare
>    Double# -> Double# -> Bool
>    with commutable = True
> 
> primop   DoubleLtOp "<##"   Compare   Double# -> Double# -> Bool
> primop   DoubleLeOp "<=##"   Compare   Double# -> Double# -> Bool
> 
> primop   DoubleAddOp   "+##"   Dyadic
>    Double# -> Double# -> Double#
>    with commutable = True
> 
> primop   DoubleSubOp   "-##"   Dyadic   Double# -> Double# -> Double#
> 
> primop   DoubleMulOp   "*##"   Dyadic
>    Double# -> Double# -> Double#
>    with commutable = True
> 
> primop   DoubleDivOp   "/##"   Dyadic
>    Double# -> Double# -> Double#
>    with can_fail = True
> 
> primop   DoubleNegOp   "negateDouble#"  Monadic   Double# -> Double#
> 
> primop   Double2IntOp   "double2Int#"          GenPrimOp  Double# -> Int#
> primop   Double2FloatOp   "double2Float#" GenPrimOp Double# -> Float#
> 
> primop   DoubleExpOp   "expDouble#"      Monadic
>    Double# -> Double#
>    with needs_wrapper = True
> 
> primop   DoubleLogOp   "logDouble#"      Monadic         
>    Double# -> Double#
>    with
>    needs_wrapper = True
>    can_fail = True
> 
> primop   DoubleSqrtOp   "sqrtDouble#"      Monadic  
>    Double# -> Double#
>    with needs_wrapper = True
> 
> primop   DoubleSinOp   "sinDouble#"      Monadic          
>    Double# -> Double#
>    with needs_wrapper = True
> 
> primop   DoubleCosOp   "cosDouble#"      Monadic          
>    Double# -> Double#
>    with needs_wrapper = True
> 
> primop   DoubleTanOp   "tanDouble#"      Monadic          
>    Double# -> Double#
>    with needs_wrapper = True
> 
> primop   DoubleAsinOp   "asinDouble#"      Monadic 
>    Double# -> Double#
>    with
>    needs_wrapper = True
>    can_fail = True
> 
> primop   DoubleAcosOp   "acosDouble#"      Monadic  
>    Double# -> Double#
>    with
>    needs_wrapper = True
>    can_fail = True
> 
> primop   DoubleAtanOp   "atanDouble#"      Monadic  
>    Double# -> Double#
>    with
>    needs_wrapper = True
> 
> primop   DoubleSinhOp   "sinhDouble#"      Monadic  
>    Double# -> Double#
>    with needs_wrapper = True
> 
> primop   DoubleCoshOp   "coshDouble#"      Monadic  
>    Double# -> Double#
>    with needs_wrapper = True
> 
> primop   DoubleTanhOp   "tanhDouble#"      Monadic  
>    Double# -> Double#
>    with needs_wrapper = True
> 
> primop   DoublePowerOp   "**##" Dyadic  
>    Double# -> Double# -> Double#
>    {Exponentiation.}
>    with needs_wrapper = True
> 
> primop   DoubleDecodeOp   "decodeDouble#" GenPrimOp    
>    Double# -> (# Int#, Int#, ByteArr# #)
>    {Convert to arbitrary-precision integer.
>     First Int\# in result is the exponent; second Int\# and ByteArr\# represent an Integer\# 
>     holding the mantissa.}
>    with out_of_line = True
> 
> ------------------------------------------------------------------------
> section "Float#" 
> 	{Operations on single-precision (32-bit) floating-point numbers.}
> ------------------------------------------------------------------------
> 
> primop   FloatGtOp  "gtFloat#"   Compare   Float# -> Float# -> Bool
> primop   FloatGeOp  "geFloat#"   Compare   Float# -> Float# -> Bool
> 
> primop   FloatEqOp  "eqFloat#"   Compare
>    Float# -> Float# -> Bool
>    with commutable = True
> 
> primop   FloatNeOp  "neFloat#"   Compare
>    Float# -> Float# -> Bool
>    with commutable = True
> 
> primop   FloatLtOp  "ltFloat#"   Compare   Float# -> Float# -> Bool
> primop   FloatLeOp  "leFloat#"   Compare   Float# -> Float# -> Bool
> 
> primop   FloatAddOp   "plusFloat#"      Dyadic            
>    Float# -> Float# -> Float#
>    with commutable = True
> 
> primop   FloatSubOp   "minusFloat#"      Dyadic      Float# -> Float# -> Float#
> 
> primop   FloatMulOp   "timesFloat#"      Dyadic    
>    Float# -> Float# -> Float#
>    with commutable = True
> 
> primop   FloatDivOp   "divideFloat#"      Dyadic  
>    Float# -> Float# -> Float#
>    with can_fail = True
> 
> primop   FloatNegOp   "negateFloat#"      Monadic    Float# -> Float#
> 
> primop   Float2IntOp   "float2Int#"      GenPrimOp  Float# -> Int#
> 
> primop   FloatExpOp   "expFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
> 
> primop   FloatLogOp   "logFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
>         can_fail = True
> 
> primop   FloatSqrtOp   "sqrtFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
> 
> primop   FloatSinOp   "sinFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
> 
> primop   FloatCosOp   "cosFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
> 
> primop   FloatTanOp   "tanFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
> 
> primop   FloatAsinOp   "asinFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
>         can_fail = True
> 
> primop   FloatAcosOp   "acosFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
>         can_fail = True
> 
> primop   FloatAtanOp   "atanFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
> 
> primop   FloatSinhOp   "sinhFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
> 
> primop   FloatCoshOp   "coshFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
> 
> primop   FloatTanhOp   "tanhFloat#"      Monadic          
>    Float# -> Float#
>    with needs_wrapper = True
> 
> primop   FloatPowerOp   "powerFloat#"      Dyadic   
>    Float# -> Float# -> Float#
>    with needs_wrapper = True
> 
> primop   Float2DoubleOp   "float2Double#" GenPrimOp  Float# -> Double#
> 
> primop   FloatDecodeOp   "decodeFloat#" GenPrimOp
>    Float# -> (# Int#, Int#, ByteArr# #)
>    {Convert to arbitrary-precision integer.
>     First Int\# in result is the exponent; second Int\# and ByteArr\# represent an Integer\# 
>     holding the mantissa.}
>    with out_of_line = True
> 
> ------------------------------------------------------------------------
> section "Arrays"
> 	{Operations on Array\#.}
> ------------------------------------------------------------------------
> 
> primop  NewArrayOp "newArray#" GenPrimOp
>    Int# -> a -> State# s -> (# State# s, MutArr# s a #)
>    {Create a new mutable array of specified size (in bytes),
>     in the specified state thread,
>     with each element containing the specified initial value.}
>    with
>    usage       = { mangle NewArrayOp [mkP, mkM, mkP] mkM }
>    out_of_line = True
> 
> primop  SameMutableArrayOp "sameMutableArray#" GenPrimOp
>    MutArr# s a -> MutArr# s a -> Bool
>    with
>    usage = { mangle SameMutableArrayOp [mkP, mkP] mkM }
> 
> primop  ReadArrayOp "readArray#" GenPrimOp
>    MutArr# s a -> Int# -> State# s -> (# State# s, a #)
>    {Read from specified index of mutable array. Result is not yet evaluated.}
>    with
>    usage = { mangle ReadArrayOp [mkM, mkP, mkP] mkM }
> 
> primop  WriteArrayOp "writeArray#" GenPrimOp
>    MutArr# s a -> Int# -> a -> State# s -> State# s
>    {Write to specified index of mutable array.}
>    with
>    usage            = { mangle WriteArrayOp [mkM, mkP, mkM, mkP] mkR }
>    has_side_effects = True
> 
> primop  IndexArrayOp "indexArray#" GenPrimOp
>    Array# a -> Int# -> (# a #)
>    {Read from specified index of immutable array. Result is packaged into
>     an unboxed singleton; the result itself is not yet evaluated.}
>    with
>    usage = { mangle  IndexArrayOp [mkM, mkP] mkM }
> 
> primop  UnsafeFreezeArrayOp "unsafeFreezeArray#" GenPrimOp
>    MutArr# s a -> State# s -> (# State# s, Array# a #)
>    {Make a mutable array immutable, without copying.}
>    with
>    usage            = { mangle UnsafeFreezeArrayOp [mkM, mkP] mkM }
>    has_side_effects = True
> 
> primop  UnsafeThawArrayOp  "unsafeThawArray#" GenPrimOp
>    Array# a -> State# s -> (# State# s, MutArr# s a #)
>    {Make an immutable array mutable, without copying.}
>    with
>    usage       = { mangle UnsafeThawArrayOp [mkM, mkP] mkM }
>    out_of_line = True
> 
> ------------------------------------------------------------------------
> section "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 fo the primitive type
> 	 being read or written.}
> 
> ------------------------------------------------------------------------
> 
> primop  NewByteArrayOp_Char "newByteArray#" GenPrimOp
>    Int# -> State# s -> (# State# s, MutByteArr# s #)
>    {Create a new mutable byte array of specified size (in bytes), in
>     the specified state thread.}
>    with out_of_line = True
> 
> primop  NewPinnedByteArrayOp_Char "newPinnedByteArray#" GenPrimOp
>    Int# -> State# s -> (# State# s, MutByteArr# s #)
>    {Create a mutable byte array that the GC guarantees not to move.}
>    with out_of_line = True
> 
> primop  ByteArrayContents_Char "byteArrayContents#" GenPrimOp
>    ByteArr# -> Addr#
>    {Intended for use with pinned arrays; otherwise very unsafe!}
> 
> primop  SameMutableByteArrayOp "sameMutableByteArray#" GenPrimOp
>    MutByteArr# s -> MutByteArr# s -> Bool
> 
> primop  UnsafeFreezeByteArrayOp "unsafeFreezeByteArray#" GenPrimOp
>    MutByteArr# s -> State# s -> (# State# s, ByteArr# #)
>    {Make a mutable byte array immutable, without copying.}
>    with
>    has_side_effects = True
> 
> primop  SizeofByteArrayOp "sizeofByteArray#" GenPrimOp  
>    ByteArr# -> Int#
> 
> primop  SizeofMutableByteArrayOp "sizeofMutableByteArray#" GenPrimOp
>    MutByteArr# s -> Int#
> 
> 
> primop IndexByteArrayOp_Char "indexCharArray#" GenPrimOp
>    ByteArr# -> Int# -> Char#
>    {Read 8-bit character; offset in bytes.}
> 
> primop IndexByteArrayOp_WideChar "indexWideCharArray#" GenPrimOp
>    ByteArr# -> Int# -> Char#
>    {Read 31-bit character; offset in 4-byte words.}
> 
> primop IndexByteArrayOp_Int "indexIntArray#" GenPrimOp
>    ByteArr# -> Int# -> Int#
> 
> primop IndexByteArrayOp_Word "indexWordArray#" GenPrimOp
>    ByteArr# -> Int# -> Word#
> 
> primop IndexByteArrayOp_Addr "indexAddrArray#" GenPrimOp
>    ByteArr# -> Int# -> Addr#
> 
> primop IndexByteArrayOp_Float "indexFloatArray#" GenPrimOp
>    ByteArr# -> Int# -> Float#
> 
> primop IndexByteArrayOp_Double "indexDoubleArray#" GenPrimOp
>    ByteArr# -> Int# -> Double#
> 
> primop IndexByteArrayOp_StablePtr "indexStablePtrArray#" GenPrimOp
>    ByteArr# -> Int# -> StablePtr# a
> 
> primop IndexByteArrayOp_Int8 "indexInt8Array#" GenPrimOp
>    ByteArr# -> Int# -> Int#
> 
> primop IndexByteArrayOp_Int16 "indexInt16Array#" GenPrimOp
>    ByteArr# -> Int# -> Int#
> 
> primop IndexByteArrayOp_Int32 "indexInt32Array#" GenPrimOp
>    ByteArr# -> Int# -> Int#
> 
> primop IndexByteArrayOp_Int64 "indexInt64Array#" GenPrimOp
>    ByteArr# -> Int# -> Int64#
> 
> primop IndexByteArrayOp_Word8 "indexWord8Array#" GenPrimOp
>    ByteArr# -> Int# -> Word#
> 
> primop IndexByteArrayOp_Word16 "indexWord16Array#" GenPrimOp
>    ByteArr# -> Int# -> Word#
> 
> primop IndexByteArrayOp_Word32 "indexWord32Array#" GenPrimOp
>    ByteArr# -> Int# -> Word#
> 
> primop IndexByteArrayOp_Word64 "indexWord64Array#" GenPrimOp
>    ByteArr# -> Int# -> Word64#
> 
> primop  ReadByteArrayOp_Char "readCharArray#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Char# #)
>    {Read 8-bit character; offset in bytes.}
> 
> primop  ReadByteArrayOp_WideChar "readWideCharArray#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Char# #)
>    {Read 31-bit character; offset in 4-byte words.}
> 
> primop  ReadByteArrayOp_Int "readIntArray#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Int# #)
> 
> primop  ReadByteArrayOp_Word "readWordArray#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Word# #)
> 
> primop  ReadByteArrayOp_Addr "readAddrArray#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Addr# #)
> 
> primop  ReadByteArrayOp_Float "readFloatArray#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Float# #)
> 
> primop  ReadByteArrayOp_Double "readDoubleArray#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Double# #)
> 
> primop  ReadByteArrayOp_StablePtr "readStablePtrArray#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, StablePtr# a #)
> 
> primop  ReadByteArrayOp_Int8 "readInt8Array#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Int# #)
> 
> primop  ReadByteArrayOp_Int16 "readInt16Array#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Int# #)
> 
> primop  ReadByteArrayOp_Int32 "readInt32Array#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Int# #)
> 
> primop  ReadByteArrayOp_Int64 "readInt64Array#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Int64# #)
> 
> primop  ReadByteArrayOp_Word8 "readWord8Array#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Word# #)
> 
> primop  ReadByteArrayOp_Word16 "readWord16Array#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Word# #)
> 
> primop  ReadByteArrayOp_Word32 "readWord32Array#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Word# #)
> 
> primop  ReadByteArrayOp_Word64 "readWord64Array#" GenPrimOp
>    MutByteArr# s -> Int# -> State# s -> (# State# s, Word64# #)
> 
> primop  WriteByteArrayOp_Char "writeCharArray#" GenPrimOp
>    MutByteArr# s -> Int# -> Char# -> State# s -> State# s
>    {Write 8-bit character; offset in bytes.}
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_WideChar "writeWideCharArray#" GenPrimOp
>    MutByteArr# s -> Int# -> Char# -> State# s -> State# s
>    {Write 31-bit character; offset in 4-byte words.}
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Int "writeIntArray#" GenPrimOp
>    MutByteArr# s -> Int# -> Int# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Word "writeWordArray#" GenPrimOp
>    MutByteArr# s -> Int# -> Word# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Addr "writeAddrArray#" GenPrimOp
>    MutByteArr# s -> Int# -> Addr# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Float "writeFloatArray#" GenPrimOp
>    MutByteArr# s -> Int# -> Float# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Double "writeDoubleArray#" GenPrimOp
>    MutByteArr# s -> Int# -> Double# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_StablePtr "writeStablePtrArray#" GenPrimOp
>    MutByteArr# s -> Int# -> StablePtr# a -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Int8 "writeInt8Array#" GenPrimOp
>    MutByteArr# s -> Int# -> Int# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Int16 "writeInt16Array#" GenPrimOp
>    MutByteArr# s -> Int# -> Int# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Int32 "writeInt32Array#" GenPrimOp
>    MutByteArr# s -> Int# -> Int# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Int64 "writeInt64Array#" GenPrimOp
>    MutByteArr# s -> Int# -> Int64# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Word8 "writeWord8Array#" GenPrimOp
>    MutByteArr# s -> Int# -> Word# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Word16 "writeWord16Array#" GenPrimOp
>    MutByteArr# s -> Int# -> Word# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Word32 "writeWord32Array#" GenPrimOp
>    MutByteArr# s -> Int# -> Word# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteByteArrayOp_Word64 "writeWord64Array#" GenPrimOp
>    MutByteArr# s -> Int# -> Word64# -> State# s -> State# s
>    with has_side_effects = True
> 
> ------------------------------------------------------------------------
> section "Addr#"
> 	{Addr\# is an arbitrary machine address assumed to point outside
> 	 the garbage-collected heap.  
> 
> 	 NB: {\tt nullAddr\#::Addr\#} is not a primop, but is defined in MkId.lhs.
> 	 It is the null address.}
> ------------------------------------------------------------------------
> 
> primop	 AddrAddOp "plusAddr#" GenPrimOp Addr# -> Int# -> Addr#
> primop	 AddrSubOp "minusAddr#" GenPrimOp Addr# -> Addr# -> Int#
> 	 {Result is meaningless if two Addr\#s are so far apart that their
> 	 difference doesn't fit in an Int\#.}
> primop	 AddrRemOp "remAddr#" GenPrimOp Addr# -> Int# -> Int#
> 	 {Return the remainder when the Addr\# arg, treated like an Int\#,
> 	  is divided by the Int\# arg.}
> 
> primop   Addr2IntOp  "addr2Int#"     GenPrimOp   Addr# -> Int#
> 	{Coerce directly from address to int. Strongly deprecated.}
> primop   Int2AddrOp   "int2Addr#"    GenPrimOp  Int# -> Addr#
> 	{Coerce directly from int to address. Strongly deprecated.}
> 
> 
> primop   AddrGtOp  "gtAddr#"   Compare   Addr# -> Addr# -> Bool
> primop   AddrGeOp  "geAddr#"   Compare   Addr# -> Addr# -> Bool
> primop   AddrEqOp  "eqAddr#"   Compare   Addr# -> Addr# -> Bool
> primop   AddrNeOp  "neAddr#"   Compare   Addr# -> Addr# -> Bool
> primop   AddrLtOp  "ltAddr#"   Compare   Addr# -> Addr# -> Bool
> primop   AddrLeOp  "leAddr#"   Compare   Addr# -> Addr# -> Bool
> 
> primop IndexOffAddrOp_Char "indexCharOffAddr#" GenPrimOp
>    Addr# -> Int# -> Char#
>    {Reads 8-bit character; offset in bytes.}
> 
> primop IndexOffAddrOp_WideChar "indexWideCharOffAddr#" GenPrimOp
>    Addr# -> Int# -> Char#
>    {Reads 31-bit character; offset in 4-byte words.}
> 
> primop IndexOffAddrOp_Int "indexIntOffAddr#" GenPrimOp
>    Addr# -> Int# -> Int#
> 
> primop IndexOffAddrOp_Word "indexWordOffAddr#" GenPrimOp
>    Addr# -> Int# -> Word#
> 
> primop IndexOffAddrOp_Addr "indexAddrOffAddr#" GenPrimOp
>    Addr# -> Int# -> Addr#
> 
> primop IndexOffAddrOp_Float "indexFloatOffAddr#" GenPrimOp
>    Addr# -> Int# -> Float#
> 
> primop IndexOffAddrOp_Double "indexDoubleOffAddr#" GenPrimOp
>    Addr# -> Int# -> Double#
> 
> primop IndexOffAddrOp_StablePtr "indexStablePtrOffAddr#" GenPrimOp
>    Addr# -> Int# -> StablePtr# a
> 
> primop IndexOffAddrOp_Int8 "indexInt8OffAddr#" GenPrimOp
>    Addr# -> Int# -> Int#
> 
> primop IndexOffAddrOp_Int16 "indexInt16OffAddr#" GenPrimOp
>    Addr# -> Int# -> Int#
> 
> primop IndexOffAddrOp_Int32 "indexInt32OffAddr#" GenPrimOp
>    Addr# -> Int# -> Int#
> 
> primop IndexOffAddrOp_Int64 "indexInt64OffAddr#" GenPrimOp
>    Addr# -> Int# -> Int64#
> 
> primop IndexOffAddrOp_Word8 "indexWord8OffAddr#" GenPrimOp
>    Addr# -> Int# -> Word#
> 
> primop IndexOffAddrOp_Word16 "indexWord16OffAddr#" GenPrimOp
>    Addr# -> Int# -> Word#
> 
> primop IndexOffAddrOp_Word32 "indexWord32OffAddr#" GenPrimOp
>    Addr# -> Int# -> Word#
> 
> primop IndexOffAddrOp_Word64 "indexWord64OffAddr#" GenPrimOp
>    Addr# -> Int# -> Word64#
> 
> primop ReadOffAddrOp_Char "readCharOffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Char# #)
>    {Reads 8-bit character; offset in bytes.}
> 
> primop ReadOffAddrOp_WideChar "readWideCharOffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Char# #)
>    {Reads 31-bit character; offset in 4-byte words.}
> 
> primop ReadOffAddrOp_Int "readIntOffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Int# #)
> 
> primop ReadOffAddrOp_Word "readWordOffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Word# #)
> 
> primop ReadOffAddrOp_Addr "readAddrOffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Addr# #)
> 
> primop ReadOffAddrOp_Float "readFloatOffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Float# #)
> 
> primop ReadOffAddrOp_Double "readDoubleOffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Double# #)
> 
> primop ReadOffAddrOp_StablePtr "readStablePtrOffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, StablePtr# a #)
> 
> primop ReadOffAddrOp_Int8 "readInt8OffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Int# #)
> 
> primop ReadOffAddrOp_Int16 "readInt16OffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Int# #)
> 
> primop ReadOffAddrOp_Int32 "readInt32OffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Int# #)
> 
> primop ReadOffAddrOp_Int64 "readInt64OffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Int64# #)
> 
> primop ReadOffAddrOp_Word8 "readWord8OffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Word# #)
> 
> primop ReadOffAddrOp_Word16 "readWord16OffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Word# #)
> 
> primop ReadOffAddrOp_Word32 "readWord32OffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Word# #)
> 
> primop ReadOffAddrOp_Word64 "readWord64OffAddr#" GenPrimOp
>    Addr# -> Int# -> State# s -> (# State# s, Word64# #)
> 
> 
> primop  WriteOffAddrOp_Char "writeCharOffAddr#" GenPrimOp
>    Addr# -> Int# -> Char# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_WideChar "writeWideCharOffAddr#" GenPrimOp
>    Addr# -> Int# -> Char# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Int "writeIntOffAddr#" GenPrimOp
>    Addr# -> Int# -> Int# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Word "writeWordOffAddr#" GenPrimOp
>    Addr# -> Int# -> Word# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Addr "writeAddrOffAddr#" GenPrimOp
>    Addr# -> Int# -> Addr# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_ForeignObj "writeForeignObjOffAddr#" GenPrimOp
>    Addr# -> Int# -> ForeignObj# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Float "writeFloatOffAddr#" GenPrimOp
>    Addr# -> Int# -> Float# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Double "writeDoubleOffAddr#" GenPrimOp
>    Addr# -> Int# -> Double# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_StablePtr "writeStablePtrOffAddr#" GenPrimOp
>    Addr# -> Int# -> StablePtr# a -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Int8 "writeInt8OffAddr#" GenPrimOp
>    Addr# -> Int# -> Int# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Int16 "writeInt16OffAddr#" GenPrimOp
>    Addr# -> Int# -> Int# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Int32 "writeInt32OffAddr#" GenPrimOp
>    Addr# -> Int# -> Int# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Int64 "writeInt64OffAddr#" GenPrimOp
>    Addr# -> Int# -> Int64# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Word8 "writeWord8OffAddr#" GenPrimOp
>    Addr# -> Int# -> Word# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Word16 "writeWord16OffAddr#" GenPrimOp
>    Addr# -> Int# -> Word# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Word32 "writeWord32OffAddr#" GenPrimOp
>    Addr# -> Int# -> Word# -> State# s -> State# s
>    with has_side_effects = True
> 
> primop  WriteOffAddrOp_Word64 "writeWord64OffAddr#" GenPrimOp
>    Addr# -> Int# -> Word64# -> State# s -> State# s
>    with has_side_effects = True
> 
> ------------------------------------------------------------------------
> section "ForeignObj#"
> 	{Operations on ForeignObj\#.  The indexing operations are
> 	all deprecated.}
> ------------------------------------------------------------------------
> 
> primop  MkForeignObjOp "mkForeignObj#" GenPrimOp
>    Addr# -> State# RealWorld -> (# State# RealWorld, ForeignObj# #)
>    with
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  WriteForeignObjOp "writeForeignObj#" GenPrimOp
>    ForeignObj# -> Addr# -> State# s -> State# s
>    with
>    has_side_effects = True
> 
> primop ForeignObjToAddrOp "foreignObjToAddr#" GenPrimOp
>    ForeignObj# -> Addr#
> 
> primop TouchOp "touch#" GenPrimOp
>    o -> State# RealWorld -> State# RealWorld
>    with
>    has_side_effects = True
> 
> primop EqForeignObj "eqForeignObj#" GenPrimOp
>    ForeignObj# -> ForeignObj# -> Bool
>    with commutable = True
> 
> primop IndexOffForeignObjOp_Char "indexCharOffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Char#
>    {Read 8-bit character; offset in bytes.}
> 
> primop IndexOffForeignObjOp_WideChar "indexWideCharOffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Char#
>    {Read 31-bit character; offset in 4-byte words.}
> 
> primop IndexOffForeignObjOp_Int "indexIntOffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Int#
> 
> primop IndexOffForeignObjOp_Word "indexWordOffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Word#
> 
> primop IndexOffForeignObjOp_Addr "indexAddrOffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Addr#
> 
> primop IndexOffForeignObjOp_Float "indexFloatOffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Float#
> 
> primop IndexOffForeignObjOp_Double "indexDoubleOffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Double#
> 
> primop IndexOffForeignObjOp_StablePtr "indexStablePtrOffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> StablePtr# a
> 
> primop IndexOffForeignObjOp_Int8 "indexInt8OffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Int#
> 
> primop IndexOffForeignObjOp_Int16 "indexInt16OffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Int#
> 
> primop IndexOffForeignObjOp_Int32 "indexInt32OffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Int#
> 
> primop IndexOffForeignObjOp_Int64 "indexInt64OffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Int64#
> 
> primop IndexOffForeignObjOp_Word8 "indexWord8OffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Word#
> 
> primop IndexOffForeignObjOp_Word16 "indexWord16OffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Word#
> 
> primop IndexOffForeignObjOp_Word32 "indexWord32OffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Word#
> 
> primop IndexOffForeignObjOp_Word64 "indexWord64OffForeignObj#" GenPrimOp
>    ForeignObj# -> Int# -> Word64#
> 
> 
> 
> ------------------------------------------------------------------------
> section "Mutable variables"
> 	{Operations on MutVar\#s, which behave like single-element mutable arrays.}
> ------------------------------------------------------------------------
> 
> primop  NewMutVarOp "newMutVar#" GenPrimOp
>    a -> State# s -> (# State# s, MutVar# s a #)
>    {Create MutVar\# with specified initial value in specified state thread.}
>    with
>    usage       = { mangle NewMutVarOp [mkM, mkP] mkM }
>    out_of_line = True
> 
> primop  ReadMutVarOp "readMutVar#" GenPrimOp
>    MutVar# s a -> State# s -> (# State# s, a #)
>    {Read contents of MutVar\#. Result is not yet evaluated.}
>    with
>    usage = { mangle ReadMutVarOp [mkM, mkP] mkM }
> 
> primop  WriteMutVarOp "writeMutVar#"  GenPrimOp
>    MutVar# s a -> a -> State# s -> State# s
>    {Write contents of MutVar\#.}
>    with
>    usage            = { mangle WriteMutVarOp [mkM, mkM, mkP] mkR }
>    has_side_effects = True
> 
> primop  SameMutVarOp "sameMutVar#" GenPrimOp
>    MutVar# s a -> MutVar# s a -> Bool
>    with
>    usage = { mangle SameMutVarOp [mkP, mkP] mkM }
> 
> -- not really the right type, but we don't know about pairs here.  The
> -- correct type is
> --
> --   MutVar# s a -> (a -> (a,b)) -> State# s -> (# State# s, b #)
> --
> primop  AtomicModifyMutVarOp "atomicModifyMutVar#" GenPrimOp
>    MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
>    with
>    usage = { mangle AtomicModifyMutVarOp [mkP, mkM, mkP] mkM }
>    has_side_effects = True
>    out_of_line = True
> 
> ------------------------------------------------------------------------
> section "Exceptions"
> ------------------------------------------------------------------------
> 
> primop  CatchOp "catch#" GenPrimOp
>           (State# RealWorld -> (# State# RealWorld, a #) )
>        -> (b -> State# RealWorld -> (# State# RealWorld, a #) ) 
>        -> State# RealWorld
>        -> (# State# RealWorld, a #)
>    with
> 	-- Catch is actually strict in its first argument
> 	-- but we don't want to tell the strictness
> 	-- analyser about that!
>    usage = { mangle CatchOp [mkM, mkM . (inFun CatchOp mkM mkM), mkP] mkM }
>         --     [mkO, mkO . (inFun mkM mkO)] mkO
>         -- might use caught action multiply
>    out_of_line = True
> 
> primop  RaiseOp "raise#" GenPrimOp
>    a -> b
>    with
>    strictness  = { \ arity -> mkStrictSig (mkTopDmdType [lazyDmd] BotRes) }
>       -- NB: result is bottom
>    usage       = { mangle RaiseOp [mkM] mkM }
>    out_of_line = True
> 
> -- raiseIO# needs to be a primop, because exceptions in the IO monad
> -- must be *precise* - we don't want the strictness analyser turning
> -- one kind of bottom into another, as it is allowed to do in pure code.
> 
> primop  RaiseIOOp "raiseIO#" GenPrimOp
>    a -> State# RealWorld -> (# State# RealWorld, b #)
>    with
>    out_of_line = True
> 
> primop  BlockAsyncExceptionsOp "blockAsyncExceptions#" GenPrimOp
>         (State# RealWorld -> (# State# RealWorld, a #))
>      -> (State# RealWorld -> (# State# RealWorld, a #))
>    with
>    out_of_line = True
> 
> primop  UnblockAsyncExceptionsOp "unblockAsyncExceptions#" GenPrimOp
>         (State# RealWorld -> (# State# RealWorld, a #))
>      -> (State# RealWorld -> (# State# RealWorld, a #))
>    with
>    out_of_line = True
> 
> ------------------------------------------------------------------------
> section "STM-accessible Mutable Variables"
> ------------------------------------------------------------------------
> 
> primop	AtomicallyOp "atomically#" GenPrimOp
>       (State# RealWorld -> (# State# RealWorld, a #) )
>    -> State# RealWorld -> (# State# RealWorld, a #)
>    with
>    out_of_line = True
>    has_side_effects = True
> 
> primop  RetryOp "retry#" GenPrimOp
>    State# RealWorld -> (# State# RealWorld, a #)
>    with 
>    out_of_line = True
>    has_side_effects = True
> 
> primop  CatchRetryOp "catchRetry#" GenPrimOp
>       (State# RealWorld -> (# State# RealWorld, a #) )
>    -> (State# RealWorld -> (# State# RealWorld, a #) )
>    -> (State# RealWorld -> (# State# RealWorld, a #) )
>    with 
>    out_of_line = True
>    has_side_effects = True
> 
> primop  CatchSTMOp "catchSTM#" GenPrimOp
>       (State# RealWorld -> (# State# RealWorld, a #) )
>    -> (b -> State# RealWorld -> (# State# RealWorld, a #) )
>    -> (State# RealWorld -> (# State# RealWorld, a #) )
>    with 
>    out_of_line = True
>    has_side_effects = True
> 
> primop	NewTVarOp "newTVar#" GenPrimOp
>        a
>     -> State# s -> (# State# s, TVar# s a #)
>    {Create a new Tar\# holding a specified initial value.}
>    with
>    out_of_line  = True
> 
> primop	ReadTVarOp "readTVar#" GenPrimOp
>        TVar# s a
>     -> State# s -> (# State# s, a #)
>    {Read contents of TVar\#.  Result is not yet evaluated.}
>    with
>    out_of_line	= True
> 
> primop	WriteTVarOp "writeTVar#" GenPrimOp
>        TVar# s a
>     -> a
>     -> State# s -> State# s
>    {Write contents of TVar\#.}
>    with
>    out_of_line	    = True
>    has_side_effects = True
> 
> primop  SameTVarOp "sameTVar#" GenPrimOp
>    TVar# s a -> TVar# s a -> Bool
> 
> 
> ------------------------------------------------------------------------
> section "Synchronized Mutable Variables"
> 	{Operations on MVar\#s, which are shared mutable variables
> 	({\it not} the same as MutVar\#s!). (Note: in a non-concurrent implementation,
> 	(MVar\# a) can be represented by (MutVar\# (Maybe a)).)}
> ------------------------------------------------------------------------
> 
> 
> primop  NewMVarOp "newMVar#"  GenPrimOp
>    State# s -> (# State# s, MVar# s a #)
>    {Create new mvar; initially empty.}
>    with
>    usage       = { mangle NewMVarOp [mkP] mkR }
>    out_of_line = True
> 
> primop  TakeMVarOp "takeMVar#" GenPrimOp
>    MVar# s a -> State# s -> (# State# s, a #)
>    {If mvar is empty, block until it becomes full.
>    Then remove and return its contents, and set it empty.}
>    with
>    usage            = { mangle TakeMVarOp [mkM, mkP] mkM }
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  TryTakeMVarOp "tryTakeMVar#" GenPrimOp
>    MVar# s a -> State# s -> (# State# s, Int#, a #)
>    {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.}
>    with
>    usage            = { mangle TryTakeMVarOp [mkM, mkP] mkM }
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  PutMVarOp "putMVar#" GenPrimOp
>    MVar# s a -> a -> State# s -> State# s
>    {If mvar is full, block until it becomes empty.
>    Then store value arg as its new contents.}
>    with
>    usage            = { mangle PutMVarOp [mkM, mkM, mkP] mkR }
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  TryPutMVarOp "tryPutMVar#" GenPrimOp
>    MVar# s a -> a -> State# s -> (# State# s, Int# #)
>    {If mvar is full, immediately return with integer 0.
>     Otherwise, store value arg as mvar's new contents, and return with integer 1.}
>    with
>    usage            = { mangle TryPutMVarOp [mkM, mkM, mkP] mkR }
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  SameMVarOp "sameMVar#" GenPrimOp
>    MVar# s a -> MVar# s a -> Bool
>    with
>    usage = { mangle SameMVarOp [mkP, mkP] mkM }
> 
> primop  IsEmptyMVarOp "isEmptyMVar#" GenPrimOp
>    MVar# s a -> State# s -> (# State# s, Int# #)
>    {Return 1 if mvar is empty; 0 otherwise.}
>    with
>    usage = { mangle IsEmptyMVarOp [mkP, mkP] mkM }
>    out_of_line = True
> 
> ------------------------------------------------------------------------
> section "Delay/wait operations"
> ------------------------------------------------------------------------
> 
> primop  DelayOp "delay#" GenPrimOp
>    Int# -> State# s -> State# s
>    {Sleep specified number of microseconds.}
>    with
>    needs_wrapper    = True
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  WaitReadOp "waitRead#" GenPrimOp
>    Int# -> State# s -> State# s
>    {Block until input is available on specified file descriptor.}
>    with
>    needs_wrapper    = True
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  WaitWriteOp "waitWrite#" GenPrimOp
>    Int# -> State# s -> State# s
>    {Block until output is possible on specified file descriptor.}
>    with
>    needs_wrapper    = True
>    has_side_effects = True
>    out_of_line      = True
> 
> 
> ------------------------------------------------------------------------
> section "Concurrency primitives"
> 	{(In a non-concurrent implementation, ThreadId\# can be as singleton
> 	type, whose (unique) value is returned by myThreadId\#.  The 
> 	other operations can be omitted.)}
> ------------------------------------------------------------------------
> 
> primop  ForkOp "fork#" GenPrimOp
>    a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
>    with
>    usage            = { mangle ForkOp [mkO, mkP] mkR }
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  KillThreadOp "killThread#"  GenPrimOp
>    ThreadId# -> a -> State# RealWorld -> State# RealWorld
>    with
>    usage            = { mangle KillThreadOp [mkP, mkM, mkP] mkR }
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  YieldOp "yield#" GenPrimOp
>    State# RealWorld -> State# RealWorld
>    with
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  MyThreadIdOp "myThreadId#" GenPrimOp
>    State# RealWorld -> (# State# RealWorld, ThreadId# #)
>    with
>    out_of_line = True
> 
> primop LabelThreadOp "labelThread#" GenPrimOp
>    ThreadId# -> Addr# -> State# RealWorld -> State# RealWorld
>    with
>    has_side_effects = True
>    out_of_line      = True
>    
> primop  IsCurrentThreadBoundOp "isCurrentThreadBound#" GenPrimOp
>    State# RealWorld -> (# State# RealWorld, Int# #)
>    with
>    out_of_line = True
> 
> ------------------------------------------------------------------------
> section "Weak pointers"
> ------------------------------------------------------------------------
> 
> -- note that tyvar "o" denotes openAlphaTyVar
> 
> primop  MkWeakOp "mkWeak#" GenPrimOp
>    o -> b -> c -> State# RealWorld -> (# State# RealWorld, Weak# b #)
>    with
>    usage            = { mangle MkWeakOp [mkZ, mkM, mkM, mkP] mkM }
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  DeRefWeakOp "deRefWeak#" GenPrimOp
>    Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)
>    with
>    usage            = { mangle DeRefWeakOp [mkM, mkP] mkM }
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  FinalizeWeakOp "finalizeWeak#" GenPrimOp
>    Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, 
>               (State# RealWorld -> (# State# RealWorld, () #)) #)
>    with
>    usage            = { mangle FinalizeWeakOp [mkM, mkP] 
>                                (mkR . (inUB FinalizeWeakOp 
>                                             [id,id,inFun FinalizeWeakOp mkR mkM])) }
>    has_side_effects = True
>    out_of_line      = True
> 
> ------------------------------------------------------------------------
> section "Stable pointers and names"
> ------------------------------------------------------------------------
> 
> primop  MakeStablePtrOp "makeStablePtr#" GenPrimOp
>    a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
>    with
>    usage            = { mangle MakeStablePtrOp [mkM, mkP] mkM }
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  DeRefStablePtrOp "deRefStablePtr#" GenPrimOp
>    StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
>    with
>    usage            = { mangle DeRefStablePtrOp [mkM, mkP] mkM }
>    needs_wrapper    = True
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  EqStablePtrOp "eqStablePtr#" GenPrimOp
>    StablePtr# a -> StablePtr# a -> Int#
>    with
>    usage            = { mangle EqStablePtrOp [mkP, mkP] mkR }
>    has_side_effects = True
> 
> primop  MakeStableNameOp "makeStableName#" GenPrimOp
>    a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
>    with
>    usage            = { mangle MakeStableNameOp [mkZ, mkP] mkR }
>    needs_wrapper    = True
>    has_side_effects = True
>    out_of_line      = True
> 
> primop  EqStableNameOp "eqStableName#" GenPrimOp
>    StableName# a -> StableName# a -> Int#
>    with
>    usage = { mangle EqStableNameOp [mkP, mkP] mkR }
> 
> primop  StableNameToIntOp "stableNameToInt#" GenPrimOp
>    StableName# a -> Int#
>    with
>    usage = { mangle StableNameToIntOp [mkP] mkR }
> 
> ------------------------------------------------------------------------
> section "Unsafe pointer equality"
> --  (#1 Bad Guy: Alistair Reid :)   
> ------------------------------------------------------------------------
> 
> primop  ReallyUnsafePtrEqualityOp "reallyUnsafePtrEquality#" GenPrimOp
>    a -> a -> Int#
>    with
>    usage = { mangle ReallyUnsafePtrEqualityOp [mkZ, mkZ] mkR }
> 
> ------------------------------------------------------------------------
> section "Parallelism"
> ------------------------------------------------------------------------
> 
> primop  ParOp "par#" GenPrimOp
>    a -> Int#
>    with
>    usage            = { mangle ParOp [mkO] mkR }
>       -- Note that Par is lazy to avoid that the sparked thing
>       -- gets evaluted strictly, which it should *not* be
>    has_side_effects = True
> 
> -- HWL: The first 4 Int# in all par... annotations denote:
> --   name, granularity info, size of result, degree of parallelism
> --      Same  structure as _seq_ i.e. returns Int#
> -- KSW: v, the second arg in parAt# and parAtForNow#, is used only to determine
> --   `the processor containing the expression v'; it is not evaluated
> 
> primop  ParGlobalOp  "parGlobal#"  GenPrimOp
>    a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
>    with
>    usage            = { mangle ParGlobalOp [mkO, mkP, mkP, mkP, mkP, mkM] mkM }
>    has_side_effects = True
> 
> primop  ParLocalOp  "parLocal#"  GenPrimOp
>    a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
>    with
>    usage            = { mangle ParLocalOp [mkO, mkP, mkP, mkP, mkP, mkM] mkM }
>    has_side_effects = True
> 
> primop  ParAtOp  "parAt#"  GenPrimOp
>    b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
>    with
>    usage            = { mangle ParAtOp [mkO, mkZ, mkP, mkP, mkP, mkP, mkM] mkM }
>    has_side_effects = True
> 
> primop  ParAtAbsOp  "parAtAbs#"  GenPrimOp
>    a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
>    with
>    usage            = { mangle ParAtAbsOp [mkO, mkP, mkP, mkP, mkP, mkM] mkM }
>    has_side_effects = True
> 
> primop  ParAtRelOp  "parAtRel#" GenPrimOp
>    a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
>    with
>    usage            = { mangle ParAtRelOp [mkO, mkP, mkP, mkP, mkP, mkM] mkM }
>    has_side_effects = True
> 
> primop  ParAtForNowOp  "parAtForNow#" GenPrimOp
>    b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
>    with
>    usage            = { mangle ParAtForNowOp [mkO, mkZ, mkP, mkP, mkP, mkP, mkM] mkM }
>    has_side_effects = True
> 
> -- copyable# and noFollow# are yet to be implemented (for GpH)
> --
> --primop  CopyableOp  "copyable#" GenPrimOp
> --   a -> Int#
> --   with
> --   usage            = { mangle CopyableOp [mkZ] mkR }
> --   has_side_effects = True
> --
> --primop  NoFollowOp "noFollow#" GenPrimOp
> --   a -> Int#
> --   with
> --   usage            = { mangle NoFollowOp [mkZ] mkR }
> --   has_side_effects = True
> 
> 
> ------------------------------------------------------------------------
> section "Tag to enum stuff"
> 	{Convert back and forth between values of enumerated types
> 	and small integers.}
> ------------------------------------------------------------------------
> 
> primop  DataToTagOp "dataToTag#" GenPrimOp
>    a -> Int#
>    with
>    strictness  = { \ arity -> mkStrictSig (mkTopDmdType [seqDmd] TopRes) }
> 	-- dataToTag# must have an evaluated argument
> 
> primop  TagToEnumOp "tagToEnum#" GenPrimOp     
>    Int# -> a
> 
> ------------------------------------------------------------------------
> section "Bytecode operations" 
> 	{Support for the bytecode interpreter and linker.}
> ------------------------------------------------------------------------
> 
> 
> primop   AddrToHValueOp "addrToHValue#" GenPrimOp
>    Addr# -> (# a #)
>    {Convert an Addr\# to a followable type.}
> 
> primop   MkApUpd0_Op "mkApUpd0#" GenPrimOp
>    BCO# -> (# a #)
>    with
>    out_of_line = True
> 
> primop  NewBCOOp "newBCO#" GenPrimOp
>    ByteArr# -> ByteArr# -> Array# a -> ByteArr# -> Int# -> ByteArr# -> State# s -> (# State# s, BCO# #)
>    with
>    has_side_effects = True
>    out_of_line      = True
> 
> ------------------------------------------------------------------------
> section "Coercion" 
> 	{{\tt unsafeCoerce\# :: a -> b} is not a primop, but is defined in MkId.lhs.}
> 
> ------------------------------------------------------------------------
> 
> 
> ------------------------------------------------------------------------
> ---                                                                  ---
> ------------------------------------------------------------------------
> 
> thats_all_folks
> 
> 
> 
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> Glasgow-haskell-users mailing list
> Glasgow-haskell-users at haskell.org
> http://www.haskell.org/mailman/listinfo/glasgow-haskell-users



More information about the Glasgow-haskell-users mailing list