Fold ghc-prim.git into ghc.git (re #8545)
[ghc.git] / compiler / prelude / primops.txt.pp
1 -----------------------------------------------------------------------
2 --
3 -- (c) 2010 The University of Glasgow
4 --
5 -- Primitive Operations and Types
6 --
7 -- For more information on PrimOps, see
8 --   http://ghc.haskell.org/trac/ghc/wiki/Commentary/PrimOps
9 --
10 -----------------------------------------------------------------------
11
12 -- This file is processed by the utility program genprimopcode to produce
13 -- a number of include files within the compiler and optionally to produce
14 -- human-readable documentation.
15 --
16 -- It should first be preprocessed.
17 --
18 -- Information on how PrimOps are implemented and the steps necessary to
19 -- add a new one can be found in the Commentary:
20 --
21 --  http://ghc.haskell.org/trac/ghc/wiki/Commentary/PrimOps
22
23 -- This file is divided into named sections, each containing or more
24 -- primop entries. Section headers have the format:
25 --
26 --      section "section-name" {description}
27 --
28 -- This information is used solely when producing documentation; it is
29 -- otherwise ignored.  The description is optional.
30 --
31 -- The format of each primop entry is as follows:
32 --
33 --      primop internal-name "name-in-program-text" type category {description} attributes
34
35 -- The default attribute values which apply if you don't specify
36 -- other ones.  Attribute values can be True, False, or arbitrary
37 -- text between curly brackets.  This is a kludge to enable
38 -- processors of this file to easily get hold of simple info
39 -- (eg, out_of_line), whilst avoiding parsing complex expressions
40 -- needed for strictness info.
41
42 -- The vector attribute is rather special. It takes a list of 3-tuples, each of
43 -- which is of the form <ELEM_TYPE,SCALAR_TYPE,LENGTH>. ELEM_TYPE is the type of
44 -- the elements in the vector; LENGTH is the length of the vector; and
45 -- SCALAR_TYPE is the scalar type used to inject to/project from vector
46 -- element. Note that ELEM_TYPE and SCALAR_TYPE are not the same; for example,
47 -- to broadcast a scalar value to a vector whose elements are of type Int8, we
48 -- use an Int#.
49
50 -- When a primtype or primop has a vector attribute, it is instantiated at each
51 -- 3-tuple in the list of 3-tuples. That is, the vector attribute allows us to
52 -- define a family of types or primops. Vector support also adds three new
53 -- keywords: VECTOR, SCALAR, and VECTUPLE. These keywords are expanded to types
54 -- derived from the 3-tuple. For the 3-tuple <Int64,INT64,2>, VECTOR expands to
55 -- Int64X2#, SCALAR expands to INT64, and VECTUPLE expands to (# INT64, INT64
56 -- #).
57
58 defaults
59    has_side_effects = False
60    out_of_line      = False   -- See Note Note [PrimOp can_fail and has_side_effects] in PrimOp
61    can_fail         = False   -- See Note Note [PrimOp can_fail and has_side_effects] in PrimOp
62    commutable       = False
63    code_size        = { primOpCodeSizeDefault }
64    strictness       = { \ arity -> mkClosedStrictSig (replicate arity topDmd) topRes }
65    fixity           = Nothing
66    llvm_only        = False
67    vector           = []
68
69 -- Currently, documentation is produced using latex, so contents of
70 -- description fields should be legal latex. Descriptions can contain
71 -- matched pairs of embedded curly brackets.
72
73 #include "MachDeps.h"
74
75 -- We need platform defines (tests for mingw32 below).
76 #include "ghc_boot_platform.h"
77
78 section "The word size story."
79         {Haskell98 specifies that signed integers (type {\tt Int})
80          must contain at least 30 bits. GHC always implements {\tt
81          Int} using the primitive type {\tt Int\#}, whose size equals
82          the {\tt MachDeps.h} constant {\tt WORD\_SIZE\_IN\_BITS}.
83          This is normally set based on the {\tt config.h} parameter
84          {\tt SIZEOF\_HSWORD}, i.e., 32 bits on 32-bit machines, 64
85          bits on 64-bit machines.  However, it can also be explicitly
86          set to a smaller number, e.g., 31 bits, to allow the
87          possibility of using tag bits. Currently GHC itself has only
88          32-bit and 64-bit variants, but 30 or 31-bit code can be
89          exported as an external core file for use in other back ends.
90
91          GHC also implements a primitive unsigned integer type {\tt
92          Word\#} which always has the same number of bits as {\tt
93          Int\#}.
94
95          In addition, GHC supports families of explicit-sized integers
96          and words at 8, 16, 32, and 64 bits, with the usual
97          arithmetic operations, comparisons, and a range of
98          conversions.  The 8-bit and 16-bit sizes are always
99          represented as {\tt Int\#} and {\tt Word\#}, and the
100          operations implemented in terms of the the primops on these
101          types, with suitable range restrictions on the results (using
102          the {\tt narrow$n$Int\#} and {\tt narrow$n$Word\#} families
103          of primops.  The 32-bit sizes are represented using {\tt
104          Int\#} and {\tt Word\#} when {\tt WORD\_SIZE\_IN\_BITS}
105          $\geq$ 32; otherwise, these are represented using distinct
106          primitive types {\tt Int32\#} and {\tt Word32\#}. These (when
107          needed) have a complete set of corresponding operations;
108          however, nearly all of these are implemented as external C
109          functions rather than as primops.  Exactly the same story
110          applies to the 64-bit sizes.  All of these details are hidden
111          under the {\tt PrelInt} and {\tt PrelWord} modules, which use
112          {\tt \#if}-defs to invoke the appropriate types and
113          operators.
114
115          Word size also matters for the families of primops for
116          indexing/reading/writing fixed-size quantities at offsets
117          from an array base, address, or foreign pointer.  Here, a
118          slightly different approach is taken.  The names of these
119          primops are fixed, but their {\it types} vary according to
120          the value of {\tt WORD\_SIZE\_IN\_BITS}. For example, if word
121          size is at least 32 bits then an operator like
122          \texttt{indexInt32Array\#} has type {\tt ByteArray\# -> Int\#
123          -> Int\#}; otherwise it has type {\tt ByteArray\# -> Int\# ->
124          Int32\#}.  This approach confines the necessary {\tt
125          \#if}-defs to this file; no conditional compilation is needed
126          in the files that expose these primops.
127
128          Finally, there are strongly deprecated primops for coercing
129          between {\tt Addr\#}, the primitive type of machine
130          addresses, and {\tt Int\#}.  These are pretty bogus anyway,
131          but will work on existing 32-bit and 64-bit GHC targets; they
132          are completely bogus when tag bits are used in {\tt Int\#},
133          so are not available in this case.  }
134
135 -- Define synonyms for indexing ops.
136
137 #if WORD_SIZE_IN_BITS < 32
138 #define INT32 Int32#
139 #define WORD32 Word32#
140 #else
141 #define INT32 Int#
142 #define WORD32 Word#
143 #endif
144
145 #if WORD_SIZE_IN_BITS < 64
146 #define INT64 Int64#
147 #define WORD64 Word64#
148 #else
149 #define INT64 Int#
150 #define WORD64 Word#
151 #endif
152
153 ------------------------------------------------------------------------
154 section "Char#"
155         {Operations on 31-bit characters.}
156 ------------------------------------------------------------------------
157
158 primtype Char#
159
160 primop   CharGtOp  "gtChar#"   Compare   Char# -> Char# -> Int#
161 primop   CharGeOp  "geChar#"   Compare   Char# -> Char# -> Int#
162
163 primop   CharEqOp  "eqChar#"   Compare
164    Char# -> Char# -> Int#
165    with commutable = True
166
167 primop   CharNeOp  "neChar#"   Compare
168    Char# -> Char# -> Int#
169    with commutable = True
170
171 primop   CharLtOp  "ltChar#"   Compare   Char# -> Char# -> Int#
172 primop   CharLeOp  "leChar#"   Compare   Char# -> Char# -> Int#
173
174 primop   OrdOp   "ord#"  GenPrimOp   Char# -> Int#
175    with code_size = 0
176
177 ------------------------------------------------------------------------
178 section "Int#"
179         {Operations on native-size integers (30+ bits).}
180 ------------------------------------------------------------------------
181
182 primtype Int#
183
184 primop   IntAddOp    "+#"    Dyadic
185    Int# -> Int# -> Int#
186    with commutable = True
187         fixity = infixl 6
188
189 primop   IntSubOp    "-#"    Dyadic   Int# -> Int# -> Int#
190    with fixity = infixl 6
191
192 primop   IntMulOp    "*#"
193    Dyadic   Int# -> Int# -> Int#
194    {Low word of signed integer multiply.}
195    with commutable = True
196         fixity = infixl 7
197
198 primop   IntMulMayOfloOp  "mulIntMayOflo#"
199    Dyadic   Int# -> Int# -> Int#
200    {Return non-zero if there is any possibility that the upper word of a
201     signed integer multiply might contain useful information.  Return
202     zero only if you are completely sure that no overflow can occur.
203     On a 32-bit platform, the recommmended implementation is to do a
204     32 x 32 -> 64 signed multiply, and subtract result[63:32] from
205     (result[31] >>signed 31).  If this is zero, meaning that the
206     upper word is merely a sign extension of the lower one, no
207     overflow can occur.
208
209     On a 64-bit platform it is not always possible to
210     acquire the top 64 bits of the result.  Therefore, a recommended
211     implementation is to take the absolute value of both operands, and
212     return 0 iff bits[63:31] of them are zero, since that means that their
213     magnitudes fit within 31 bits, so the magnitude of the product must fit
214     into 62 bits.
215
216     If in doubt, return non-zero, but do make an effort to create the
217     correct answer for small args, since otherwise the performance of
218     \texttt{(*) :: Integer -> Integer -> Integer} will be poor.
219    }
220    with commutable = True
221
222 primop   IntQuotOp    "quotInt#"    Dyadic
223    Int# -> Int# -> Int#
224    {Rounds towards zero.}
225    with can_fail = True
226
227 primop   IntRemOp    "remInt#"    Dyadic
228    Int# -> Int# -> Int#
229    {Satisfies \texttt{(quotInt\# x y) *\# y +\# (remInt\# x y) == x}.}
230    with can_fail = True
231
232 primop   IntQuotRemOp "quotRemInt#"    GenPrimOp
233    Int# -> Int# -> (# Int#, Int# #)
234    {Rounds towards zero.}
235    with can_fail = True
236
237 primop   AndIOp   "andI#"   Dyadic    Int# -> Int# -> Int#
238    with commutable = True
239
240 primop   OrIOp   "orI#"     Dyadic    Int# -> Int# -> Int#
241    with commutable = True
242
243 primop   XorIOp   "xorI#"   Dyadic    Int# -> Int# -> Int#
244    with commutable = True
245
246 primop   NotIOp   "notI#"   Monadic   Int# -> Int#
247
248 primop   IntNegOp    "negateInt#"    Monadic   Int# -> Int#
249 primop   IntAddCOp   "addIntC#"    GenPrimOp   Int# -> Int# -> (# Int#, Int# #)
250          {Add with carry.  First member of result is (wrapped) sum;
251           second member is 0 iff no overflow occured.}
252    with code_size = 2
253
254 primop   IntSubCOp   "subIntC#"    GenPrimOp   Int# -> Int# -> (# Int#, Int# #)
255          {Subtract with carry.  First member of result is (wrapped) difference;
256           second member is 0 iff no overflow occured.}
257    with code_size = 2
258
259 primop   IntGtOp  ">#"   Compare   Int# -> Int# -> Int#
260    with fixity = infix 4
261
262 primop   IntGeOp  ">=#"   Compare   Int# -> Int# -> Int#
263    with fixity = infix 4
264
265 primop   IntEqOp  "==#"   Compare
266    Int# -> Int# -> Int#
267    with commutable = True
268         fixity = infix 4
269
270 primop   IntNeOp  "/=#"   Compare
271    Int# -> Int# -> Int#
272    with commutable = True
273         fixity = infix 4
274
275 primop   IntLtOp  "<#"   Compare   Int# -> Int# -> Int#
276    with fixity = infix 4
277
278 primop   IntLeOp  "<=#"   Compare   Int# -> Int# -> Int#
279    with fixity = infix 4
280
281 primop   ChrOp   "chr#"   GenPrimOp   Int# -> Char#
282    with code_size = 0
283
284 primop   Int2WordOp "int2Word#" GenPrimOp Int# -> Word#
285    with code_size = 0
286
287 primop   Int2FloatOp   "int2Float#"      GenPrimOp  Int# -> Float#
288 primop   Int2DoubleOp   "int2Double#"          GenPrimOp  Int# -> Double#
289
290 primop   Word2FloatOp   "word2Float#"      GenPrimOp  Word# -> Float#
291 primop   Word2DoubleOp   "word2Double#"          GenPrimOp  Word# -> Double#
292
293 primop   ISllOp   "uncheckedIShiftL#" GenPrimOp  Int# -> Int# -> Int#
294          {Shift left.  Result undefined if shift amount is not
295           in the range 0 to word size - 1 inclusive.}
296 primop   ISraOp   "uncheckedIShiftRA#" GenPrimOp Int# -> Int# -> Int#
297          {Shift right arithmetic.  Result undefined if shift amount is not
298           in the range 0 to word size - 1 inclusive.}
299 primop   ISrlOp   "uncheckedIShiftRL#" GenPrimOp Int# -> Int# -> Int#
300          {Shift right logical.  Result undefined if shift amount is not
301           in the range 0 to word size - 1 inclusive.}
302
303 ------------------------------------------------------------------------
304 section "Word#"
305         {Operations on native-sized unsigned words (30+ bits).}
306 ------------------------------------------------------------------------
307
308 primtype Word#
309
310 primop   WordAddOp   "plusWord#"   Dyadic   Word# -> Word# -> Word#
311    with commutable = True
312
313 -- Returns (# high, low #) (or equivalently, (# carry, low #))
314 primop   WordAdd2Op  "plusWord2#"  GenPrimOp
315    Word# -> Word# -> (# Word#, Word# #)
316    with commutable = True
317
318 primop   WordSubOp   "minusWord#"   Dyadic   Word# -> Word# -> Word#
319
320 primop   WordMulOp   "timesWord#"   Dyadic   Word# -> Word# -> Word#
321    with commutable = True
322
323 -- Returns (# high, low #)
324 primop   WordMul2Op  "timesWord2#"   GenPrimOp
325    Word# -> Word# -> (# Word#, Word# #)
326    with commutable = True
327
328 primop   WordQuotOp   "quotWord#"   Dyadic   Word# -> Word# -> Word#
329    with can_fail = True
330
331 primop   WordRemOp   "remWord#"   Dyadic   Word# -> Word# -> Word#
332    with can_fail = True
333
334 primop   WordQuotRemOp "quotRemWord#" GenPrimOp
335    Word# -> Word# -> (# Word#, Word# #)
336    with can_fail = True
337
338 -- Takes high word of dividend, then low word of dividend, then divisor.
339 -- Requires that high word is not divisible by divisor.
340 primop   WordQuotRem2Op "quotRemWord2#" GenPrimOp
341    Word# -> Word# -> Word# -> (# Word#, Word# #)
342    with can_fail = True
343
344 primop   AndOp   "and#"   Dyadic   Word# -> Word# -> Word#
345    with commutable = True
346
347 primop   OrOp   "or#"   Dyadic   Word# -> Word# -> Word#
348    with commutable = True
349
350 primop   XorOp   "xor#"   Dyadic   Word# -> Word# -> Word#
351    with commutable = True
352
353 primop   NotOp   "not#"   Monadic   Word# -> Word#
354
355 primop   SllOp   "uncheckedShiftL#"   GenPrimOp   Word# -> Int# -> Word#
356          {Shift left logical.   Result undefined if shift amount is not
357           in the range 0 to word size - 1 inclusive.}
358 primop   SrlOp   "uncheckedShiftRL#"   GenPrimOp   Word# -> Int# -> Word#
359          {Shift right logical.   Result undefined if shift  amount is not
360           in the range 0 to word size - 1 inclusive.}
361
362 primop   Word2IntOp   "word2Int#"   GenPrimOp   Word# -> Int#
363    with code_size = 0
364
365 primop   WordGtOp   "gtWord#"   Compare   Word# -> Word# -> Int#
366 primop   WordGeOp   "geWord#"   Compare   Word# -> Word# -> Int#
367 primop   WordEqOp   "eqWord#"   Compare   Word# -> Word# -> Int#
368 primop   WordNeOp   "neWord#"   Compare   Word# -> Word# -> Int#
369 primop   WordLtOp   "ltWord#"   Compare   Word# -> Word# -> Int#
370 primop   WordLeOp   "leWord#"   Compare   Word# -> Word# -> Int#
371
372 primop   PopCnt8Op   "popCnt8#"   Monadic   Word# -> Word#
373     {Count the number of set bits in the lower 8 bits of a word.}
374 primop   PopCnt16Op   "popCnt16#"   Monadic   Word# -> Word#
375     {Count the number of set bits in the lower 16 bits of a word.}
376 primop   PopCnt32Op   "popCnt32#"   Monadic   Word# -> Word#
377     {Count the number of set bits in the lower 32 bits of a word.}
378 primop   PopCnt64Op   "popCnt64#"   GenPrimOp   WORD64 -> Word#
379     {Count the number of set bits in a 64-bit word.}
380 primop   PopCntOp   "popCnt#"   Monadic   Word# -> Word#
381     {Count the number of set bits in a word.}
382
383 primop   BSwap16Op   "byteSwap16#"   Monadic   Word# -> Word#
384     {Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. }
385 primop   BSwap32Op   "byteSwap32#"   Monadic   Word# -> Word#
386     {Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. }
387 primop   BSwap64Op   "byteSwap64#"   Monadic   WORD64 -> WORD64
388     {Swap bytes in a 64 bits of a word.}
389 primop   BSwapOp     "byteSwap#"     Monadic   Word# -> Word#
390     {Swap bytes in a word.}
391
392 ------------------------------------------------------------------------
393 section "Narrowings"
394         {Explicit narrowing of native-sized ints or words.}
395 ------------------------------------------------------------------------
396
397 primop   Narrow8IntOp      "narrow8Int#"      Monadic   Int# -> Int#
398 primop   Narrow16IntOp     "narrow16Int#"     Monadic   Int# -> Int#
399 primop   Narrow32IntOp     "narrow32Int#"     Monadic   Int# -> Int#
400 primop   Narrow8WordOp     "narrow8Word#"     Monadic   Word# -> Word#
401 primop   Narrow16WordOp    "narrow16Word#"    Monadic   Word# -> Word#
402 primop   Narrow32WordOp    "narrow32Word#"    Monadic   Word# -> Word#
403
404
405 #if WORD_SIZE_IN_BITS < 32
406 ------------------------------------------------------------------------
407 section "Int32#"
408         {Operations on 32-bit integers ({\tt Int32\#}).  This type is only used
409          if plain {\tt Int\#} has less than 32 bits.  In any case, the operations
410          are not primops; they are implemented (if needed) as ccalls instead.}
411 ------------------------------------------------------------------------
412
413 primtype Int32#
414
415 ------------------------------------------------------------------------
416 section "Word32#"
417         {Operations on 32-bit unsigned words. This type is only used
418          if plain {\tt Word\#} has less than 32 bits. In any case, the operations
419          are not primops; they are implemented (if needed) as ccalls instead.}
420 ------------------------------------------------------------------------
421
422 primtype Word32#
423
424 #endif
425
426
427 #if WORD_SIZE_IN_BITS < 64
428 ------------------------------------------------------------------------
429 section "Int64#"
430         {Operations on 64-bit unsigned words. This type is only used
431          if plain {\tt Int\#} has less than 64 bits. In any case, the operations
432          are not primops; they are implemented (if needed) as ccalls instead.}
433 ------------------------------------------------------------------------
434
435 primtype Int64#
436
437 ------------------------------------------------------------------------
438 section "Word64#"
439         {Operations on 64-bit unsigned words. This type is only used
440          if plain {\tt Word\#} has less than 64 bits. In any case, the operations
441          are not primops; they are implemented (if needed) as ccalls instead.}
442 ------------------------------------------------------------------------
443
444 primtype Word64#
445
446 #endif
447
448 ------------------------------------------------------------------------
449 section "Double#"
450         {Operations on double-precision (64 bit) floating-point numbers.}
451 ------------------------------------------------------------------------
452
453 primtype Double#
454
455 primop   DoubleGtOp ">##"   Compare   Double# -> Double# -> Int#
456    with fixity = infix 4
457
458 primop   DoubleGeOp ">=##"   Compare   Double# -> Double# -> Int#
459    with fixity = infix 4
460
461 primop DoubleEqOp "==##"   Compare
462    Double# -> Double# -> Int#
463    with commutable = True
464         fixity = infix 4
465
466 primop DoubleNeOp "/=##"   Compare
467    Double# -> Double# -> Int#
468    with commutable = True
469         fixity = infix 4
470
471 primop   DoubleLtOp "<##"   Compare   Double# -> Double# -> Int#
472    with fixity = infix 4
473
474 primop   DoubleLeOp "<=##"   Compare   Double# -> Double# -> Int#
475    with fixity = infix 4
476
477 primop   DoubleAddOp   "+##"   Dyadic
478    Double# -> Double# -> Double#
479    with commutable = True
480         fixity = infixl 6
481
482 primop   DoubleSubOp   "-##"   Dyadic   Double# -> Double# -> Double#
483    with fixity = infixl 6
484
485 primop   DoubleMulOp   "*##"   Dyadic
486    Double# -> Double# -> Double#
487    with commutable = True
488         fixity = infixl 7
489
490 primop   DoubleDivOp   "/##"   Dyadic
491    Double# -> Double# -> Double#
492    with can_fail = True
493         fixity = infixl 7
494
495 primop   DoubleNegOp   "negateDouble#"  Monadic   Double# -> Double#
496
497 primop   Double2IntOp   "double2Int#"          GenPrimOp  Double# -> Int#
498    {Truncates a {\tt Double#} value to the nearest {\tt Int#}.
499     Results are undefined if the truncation if truncation yields
500     a value outside the range of {\tt Int#}.}
501
502 primop   Double2FloatOp   "double2Float#" GenPrimOp Double# -> Float#
503
504 primop   DoubleExpOp   "expDouble#"      Monadic
505    Double# -> Double#
506    with
507    code_size = { primOpCodeSizeForeignCall }
508
509 primop   DoubleLogOp   "logDouble#"      Monadic
510    Double# -> Double#
511    with
512    code_size = { primOpCodeSizeForeignCall }
513    can_fail = True
514
515 primop   DoubleSqrtOp   "sqrtDouble#"      Monadic
516    Double# -> Double#
517    with
518    code_size = { primOpCodeSizeForeignCall }
519
520 primop   DoubleSinOp   "sinDouble#"      Monadic
521    Double# -> Double#
522    with
523    code_size = { primOpCodeSizeForeignCall }
524
525 primop   DoubleCosOp   "cosDouble#"      Monadic
526    Double# -> Double#
527    with
528    code_size = { primOpCodeSizeForeignCall }
529
530 primop   DoubleTanOp   "tanDouble#"      Monadic
531    Double# -> Double#
532    with
533    code_size = { primOpCodeSizeForeignCall }
534
535 primop   DoubleAsinOp   "asinDouble#"      Monadic
536    Double# -> Double#
537    with
538    code_size = { primOpCodeSizeForeignCall }
539    can_fail = True
540
541 primop   DoubleAcosOp   "acosDouble#"      Monadic
542    Double# -> Double#
543    with
544    code_size = { primOpCodeSizeForeignCall }
545    can_fail = True
546
547 primop   DoubleAtanOp   "atanDouble#"      Monadic
548    Double# -> Double#
549    with
550    code_size = { primOpCodeSizeForeignCall }
551
552 primop   DoubleSinhOp   "sinhDouble#"      Monadic
553    Double# -> Double#
554    with
555    code_size = { primOpCodeSizeForeignCall }
556
557 primop   DoubleCoshOp   "coshDouble#"      Monadic
558    Double# -> Double#
559    with
560    code_size = { primOpCodeSizeForeignCall }
561
562 primop   DoubleTanhOp   "tanhDouble#"      Monadic
563    Double# -> Double#
564    with
565    code_size = { primOpCodeSizeForeignCall }
566
567 primop   DoublePowerOp   "**##" Dyadic
568    Double# -> Double# -> Double#
569    {Exponentiation.}
570    with
571    code_size = { primOpCodeSizeForeignCall }
572
573 primop   DoubleDecode_2IntOp   "decodeDouble_2Int#" GenPrimOp
574    Double# -> (# Int#, Word#, Word#, Int# #)
575    {Convert to integer.
576     First component of the result is -1 or 1, indicating the sign of the
577     mantissa. The next two are the high and low 32 bits of the mantissa
578     respectively, and the last is the exponent.}
579    with out_of_line = True
580
581 ------------------------------------------------------------------------
582 section "Float#"
583         {Operations on single-precision (32-bit) floating-point numbers.}
584 ------------------------------------------------------------------------
585
586 primtype Float#
587
588 primop   FloatGtOp  "gtFloat#"   Compare   Float# -> Float# -> Int#
589 primop   FloatGeOp  "geFloat#"   Compare   Float# -> Float# -> Int#
590
591 primop   FloatEqOp  "eqFloat#"   Compare
592    Float# -> Float# -> Int#
593    with commutable = True
594
595 primop   FloatNeOp  "neFloat#"   Compare
596    Float# -> Float# -> Int#
597    with commutable = True
598
599 primop   FloatLtOp  "ltFloat#"   Compare   Float# -> Float# -> Int#
600 primop   FloatLeOp  "leFloat#"   Compare   Float# -> Float# -> Int#
601
602 primop   FloatAddOp   "plusFloat#"      Dyadic
603    Float# -> Float# -> Float#
604    with commutable = True
605
606 primop   FloatSubOp   "minusFloat#"      Dyadic      Float# -> Float# -> Float#
607
608 primop   FloatMulOp   "timesFloat#"      Dyadic
609    Float# -> Float# -> Float#
610    with commutable = True
611
612 primop   FloatDivOp   "divideFloat#"      Dyadic
613    Float# -> Float# -> Float#
614    with can_fail = True
615
616 primop   FloatNegOp   "negateFloat#"      Monadic    Float# -> Float#
617
618 primop   Float2IntOp   "float2Int#"      GenPrimOp  Float# -> Int#
619    {Truncates a {\tt Float#} value to the nearest {\tt Int#}.
620     Results are undefined if the truncation if truncation yields
621     a value outside the range of {\tt Int#}.}
622
623 primop   FloatExpOp   "expFloat#"      Monadic
624    Float# -> Float#
625    with
626    code_size = { primOpCodeSizeForeignCall }
627
628 primop   FloatLogOp   "logFloat#"      Monadic
629    Float# -> Float#
630    with
631    code_size = { primOpCodeSizeForeignCall }
632    can_fail = True
633
634 primop   FloatSqrtOp   "sqrtFloat#"      Monadic
635    Float# -> Float#
636    with
637    code_size = { primOpCodeSizeForeignCall }
638
639 primop   FloatSinOp   "sinFloat#"      Monadic
640    Float# -> Float#
641    with
642    code_size = { primOpCodeSizeForeignCall }
643
644 primop   FloatCosOp   "cosFloat#"      Monadic
645    Float# -> Float#
646    with
647    code_size = { primOpCodeSizeForeignCall }
648
649 primop   FloatTanOp   "tanFloat#"      Monadic
650    Float# -> Float#
651    with
652    code_size = { primOpCodeSizeForeignCall }
653
654 primop   FloatAsinOp   "asinFloat#"      Monadic
655    Float# -> Float#
656    with
657    code_size = { primOpCodeSizeForeignCall }
658    can_fail = True
659
660 primop   FloatAcosOp   "acosFloat#"      Monadic
661    Float# -> Float#
662    with
663    code_size = { primOpCodeSizeForeignCall }
664    can_fail = True
665
666 primop   FloatAtanOp   "atanFloat#"      Monadic
667    Float# -> Float#
668    with
669    code_size = { primOpCodeSizeForeignCall }
670
671 primop   FloatSinhOp   "sinhFloat#"      Monadic
672    Float# -> Float#
673    with
674    code_size = { primOpCodeSizeForeignCall }
675
676 primop   FloatCoshOp   "coshFloat#"      Monadic
677    Float# -> Float#
678    with
679    code_size = { primOpCodeSizeForeignCall }
680
681 primop   FloatTanhOp   "tanhFloat#"      Monadic
682    Float# -> Float#
683    with
684    code_size = { primOpCodeSizeForeignCall }
685
686 primop   FloatPowerOp   "powerFloat#"      Dyadic
687    Float# -> Float# -> Float#
688    with
689    code_size = { primOpCodeSizeForeignCall }
690
691 primop   Float2DoubleOp   "float2Double#" GenPrimOp  Float# -> Double#
692
693 primop   FloatDecode_IntOp   "decodeFloat_Int#" GenPrimOp
694    Float# -> (# Int#, Int# #)
695    {Convert to integers.
696     First {\tt Int\#} in result is the mantissa; second is the exponent.}
697    with out_of_line = True
698
699 ------------------------------------------------------------------------
700 section "Arrays"
701         {Operations on {\tt Array\#}.}
702 ------------------------------------------------------------------------
703
704 primtype Array# a
705
706 primtype MutableArray# s a
707
708 primop  NewArrayOp "newArray#" GenPrimOp
709    Int# -> a -> State# s -> (# State# s, MutableArray# s a #)
710    {Create a new mutable array with the specified number of elements,
711     in the specified state thread,
712     with each element containing the specified initial value.}
713    with
714    out_of_line = True
715    has_side_effects = True
716
717 primop  SameMutableArrayOp "sameMutableArray#" GenPrimOp
718    MutableArray# s a -> MutableArray# s a -> Int#
719
720 primop  ReadArrayOp "readArray#" GenPrimOp
721    MutableArray# s a -> Int# -> State# s -> (# State# s, a #)
722    {Read from specified index of mutable array. Result is not yet evaluated.}
723    with
724    has_side_effects = True
725    can_fail         = True
726
727 primop  WriteArrayOp "writeArray#" GenPrimOp
728    MutableArray# s a -> Int# -> a -> State# s -> State# s
729    {Write to specified index of mutable array.}
730    with
731    has_side_effects = True
732    can_fail         = True
733    code_size        = 2 -- card update too
734
735 primop  SizeofArrayOp "sizeofArray#" GenPrimOp
736    Array# a -> Int#
737    {Return the number of elements in the array.}
738
739 primop  SizeofMutableArrayOp "sizeofMutableArray#" GenPrimOp
740    MutableArray# s a -> Int#
741    {Return the number of elements in the array.}
742
743 primop  IndexArrayOp "indexArray#" GenPrimOp
744    Array# a -> Int# -> (# a #)
745    {Read from specified index of immutable array. Result is packaged into
746     an unboxed singleton; the result itself is not yet evaluated.}
747    with
748    can_fail         = True
749
750 primop  UnsafeFreezeArrayOp "unsafeFreezeArray#" GenPrimOp
751    MutableArray# s a -> State# s -> (# State# s, Array# a #)
752    {Make a mutable array immutable, without copying.}
753    with
754    has_side_effects = True
755
756 primop  UnsafeThawArrayOp  "unsafeThawArray#" GenPrimOp
757    Array# a -> State# s -> (# State# s, MutableArray# s a #)
758    {Make an immutable array mutable, without copying.}
759    with
760    out_of_line = True
761    has_side_effects = True
762
763 primop  CopyArrayOp "copyArray#" GenPrimOp
764   Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s
765   {Given a source array, an offset into the source array, a
766    destination array, an offset into the destination array, and a
767    number of elements to copy, copy the elements from the source array
768    to the destination array. Both arrays must fully contain the
769    specified ranges, but this is not checked. The two arrays must not
770    be the same array in different states, but this is not checked
771    either.}
772   with
773   out_of_line      = True
774   has_side_effects = True
775   can_fail         = True
776
777 primop  CopyMutableArrayOp "copyMutableArray#" GenPrimOp
778   MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s
779   {Given a source array, an offset into the source array, a
780    destination array, an offset into the destination array, and a
781    number of elements to copy, copy the elements from the source array
782    to the destination array. The source and destination arrays can
783    refer to the same array. Both arrays must fully contain the
784    specified ranges, but this is not checked.}
785   with
786   out_of_line      = True
787   has_side_effects = True
788   can_fail         = True
789
790 primop  CloneArrayOp "cloneArray#" GenPrimOp
791   Array# a -> Int# -> Int# -> Array# a
792   {Given a source array, an offset into the source array, and a number
793    of elements to copy, create a new array with the elements from the
794    source array. The provided array must fully contain the specified
795    range, but this is not checked.}
796   with
797   out_of_line      = True
798   has_side_effects = True
799   can_fail         = True
800
801 primop  CloneMutableArrayOp "cloneMutableArray#" GenPrimOp
802   MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s, MutableArray# s a #)
803   {Given a source array, an offset into the source array, and a number
804    of elements to copy, create a new array with the elements from the
805    source array. The provided array must fully contain the specified
806    range, but this is not checked.}
807   with
808   out_of_line      = True
809   has_side_effects = True
810   can_fail         = True
811
812 primop  FreezeArrayOp "freezeArray#" GenPrimOp
813   MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s, Array# a #)
814   {Given a source array, an offset into the source array, and a number
815    of elements to copy, create a new array with the elements from the
816    source array. The provided array must fully contain the specified
817    range, but this is not checked.}
818   with
819   out_of_line      = True
820   has_side_effects = True
821   can_fail         = True
822
823 primop  ThawArrayOp "thawArray#" GenPrimOp
824   Array# a -> Int# -> Int# -> State# s -> (# State# s, MutableArray# s a #)
825   {Given a source array, an offset into the source array, and a number
826    of elements to copy, create a new array with the elements from the
827    source array. The provided array must fully contain the specified
828    range, but this is not checked.}
829   with
830   out_of_line      = True
831   has_side_effects = True
832   can_fail         = True
833
834 primop CasArrayOp  "casArray#" GenPrimOp
835    MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s, Int#, a #)
836    {Unsafe, machine-level atomic compare and swap on an element within an Array.}
837    with
838    out_of_line = True
839    has_side_effects = True
840
841
842 ------------------------------------------------------------------------
843 section "Small Arrays"
844
845         {Operations on {\tt SmallArray\#}. A {\tt SmallArray\#} works
846          just like an {\tt Array\#}, except that its implementation is
847          optimized for small arrays (i.e. no more than 128 elements.)}
848
849 ------------------------------------------------------------------------
850
851 primtype SmallArray# a
852
853 primtype SmallMutableArray# s a
854
855 primop  NewSmallArrayOp "newSmallArray#" GenPrimOp
856    Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
857    {Create a new mutable array with the specified number of elements,
858     in the specified state thread,
859     with each element containing the specified initial value.}
860    with
861    out_of_line = True
862    has_side_effects = True
863
864 primop  SameSmallMutableArrayOp "sameSmallMutableArray#" GenPrimOp
865    SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
866
867 primop  ReadSmallArrayOp "readSmallArray#" GenPrimOp
868    SmallMutableArray# s a -> Int# -> State# s -> (# State# s, a #)
869    {Read from specified index of mutable array. Result is not yet evaluated.}
870    with
871    has_side_effects = True
872    can_fail         = True
873
874 primop  WriteSmallArrayOp "writeSmallArray#" GenPrimOp
875    SmallMutableArray# s a -> Int# -> a -> State# s -> State# s
876    {Write to specified index of mutable array.}
877    with
878    has_side_effects = True
879    can_fail         = True
880
881 primop  SizeofSmallArrayOp "sizeofSmallArray#" GenPrimOp
882    SmallArray# a -> Int#
883    {Return the number of elements in the array.}
884
885 primop  SizeofSmallMutableArrayOp "sizeofSmallMutableArray#" GenPrimOp
886    SmallMutableArray# s a -> Int#
887    {Return the number of elements in the array.}
888
889 primop  IndexSmallArrayOp "indexSmallArray#" GenPrimOp
890    SmallArray# a -> Int# -> (# a #)
891    {Read from specified index of immutable array. Result is packaged into
892     an unboxed singleton; the result itself is not yet evaluated.}
893    with
894    can_fail         = True
895
896 primop  UnsafeFreezeSmallArrayOp "unsafeFreezeSmallArray#" GenPrimOp
897    SmallMutableArray# s a -> State# s -> (# State# s, SmallArray# a #)
898    {Make a mutable array immutable, without copying.}
899    with
900    has_side_effects = True
901
902 primop  UnsafeThawSmallArrayOp  "unsafeThawSmallArray#" GenPrimOp
903    SmallArray# a -> State# s -> (# State# s, SmallMutableArray# s a #)
904    {Make an immutable array mutable, without copying.}
905    with
906    out_of_line = True
907    has_side_effects = True
908
909 -- The code_size is only correct for the case when the copy family of
910 -- primops aren't inlined. It would be nice to keep track of both.
911
912 primop  CopySmallArrayOp "copySmallArray#" GenPrimOp
913   SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s
914   {Given a source array, an offset into the source array, a
915    destination array, an offset into the destination array, and a
916    number of elements to copy, copy the elements from the source array
917    to the destination array. Both arrays must fully contain the
918    specified ranges, but this is not checked. The two arrays must not
919    be the same array in different states, but this is not checked
920    either.}
921   with
922   out_of_line      = True
923   has_side_effects = True
924   can_fail         = True
925
926 primop  CopySmallMutableArrayOp "copySmallMutableArray#" GenPrimOp
927   SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s
928   {Given a source array, an offset into the source array, a
929    destination array, an offset into the destination array, and a
930    number of elements to copy, copy the elements from the source array
931    to the destination array. The source and destination arrays can
932    refer to the same array. Both arrays must fully contain the
933    specified ranges, but this is not checked.}
934   with
935   out_of_line      = True
936   has_side_effects = True
937   can_fail         = True
938
939 primop  CloneSmallArrayOp "cloneSmallArray#" GenPrimOp
940   SmallArray# a -> Int# -> Int# -> SmallArray# a
941   {Given a source array, an offset into the source array, and a number
942    of elements to copy, create a new array with the elements from the
943    source array. The provided array must fully contain the specified
944    range, but this is not checked.}
945   with
946   out_of_line      = True
947   has_side_effects = True
948   can_fail         = True
949
950 primop  CloneSmallMutableArrayOp "cloneSmallMutableArray#" GenPrimOp
951   SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s, SmallMutableArray# s a #)
952   {Given a source array, an offset into the source array, and a number
953    of elements to copy, create a new array with the elements from the
954    source array. The provided array must fully contain the specified
955    range, but this is not checked.}
956   with
957   out_of_line      = True
958   has_side_effects = True
959   can_fail         = True
960
961 primop  FreezeSmallArrayOp "freezeSmallArray#" GenPrimOp
962   SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s, SmallArray# a #)
963   {Given a source array, an offset into the source array, and a number
964    of elements to copy, create a new array with the elements from the
965    source array. The provided array must fully contain the specified
966    range, but this is not checked.}
967   with
968   out_of_line      = True
969   has_side_effects = True
970   can_fail         = True
971
972 primop  ThawSmallArrayOp "thawSmallArray#" GenPrimOp
973   SmallArray# a -> Int# -> Int# -> State# s -> (# State# s, SmallMutableArray# s a #)
974   {Given a source array, an offset into the source array, and a number
975    of elements to copy, create a new array with the elements from the
976    source array. The provided array must fully contain the specified
977    range, but this is not checked.}
978   with
979   out_of_line      = True
980   has_side_effects = True
981   can_fail         = True
982
983 primop CasSmallArrayOp  "casSmallArray#" GenPrimOp
984    SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s, Int#, a #)
985    {Unsafe, machine-level atomic compare and swap on an element within an array.}
986    with
987    out_of_line = True
988    has_side_effects = True
989
990 ------------------------------------------------------------------------
991 section "Byte Arrays"
992         {Operations on {\tt ByteArray\#}. A {\tt ByteArray\#} is a just a region of
993          raw memory in the garbage-collected heap, which is not
994          scanned for pointers. It carries its own size (in bytes).
995          There are
996          three sets of operations for accessing byte array contents:
997          index for reading from immutable byte arrays, and read/write
998          for mutable byte arrays.  Each set contains operations for a
999          range of useful primitive data types.  Each operation takes
1000          an offset measured in terms of the size of the primitive type
1001          being read or written.}
1002
1003 ------------------------------------------------------------------------
1004
1005 primtype ByteArray#
1006
1007 primtype MutableByteArray# s
1008
1009 primop  NewByteArrayOp_Char "newByteArray#" GenPrimOp
1010    Int# -> State# s -> (# State# s, MutableByteArray# s #)
1011    {Create a new mutable byte array of specified size (in bytes), in
1012     the specified state thread.}
1013    with out_of_line = True
1014         has_side_effects = True
1015
1016 primop  NewPinnedByteArrayOp_Char "newPinnedByteArray#" GenPrimOp
1017    Int# -> State# s -> (# State# s, MutableByteArray# s #)
1018    {Create a mutable byte array that the GC guarantees not to move.}
1019    with out_of_line = True
1020         has_side_effects = True
1021
1022 primop  NewAlignedPinnedByteArrayOp_Char "newAlignedPinnedByteArray#" GenPrimOp
1023    Int# -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
1024    {Create a mutable byte array, aligned by the specified amount, that the GC guarantees not to move.}
1025    with out_of_line = True
1026         has_side_effects = True
1027
1028 primop  ByteArrayContents_Char "byteArrayContents#" GenPrimOp
1029    ByteArray# -> Addr#
1030    {Intended for use with pinned arrays; otherwise very unsafe!}
1031
1032 primop  SameMutableByteArrayOp "sameMutableByteArray#" GenPrimOp
1033    MutableByteArray# s -> MutableByteArray# s -> Int#
1034
1035 primop  UnsafeFreezeByteArrayOp "unsafeFreezeByteArray#" GenPrimOp
1036    MutableByteArray# s -> State# s -> (# State# s, ByteArray# #)
1037    {Make a mutable byte array immutable, without copying.}
1038    with
1039    has_side_effects = True
1040
1041 primop  SizeofByteArrayOp "sizeofByteArray#" GenPrimOp
1042    ByteArray# -> Int#
1043    {Return the size of the array in bytes.}
1044
1045 primop  SizeofMutableByteArrayOp "sizeofMutableByteArray#" GenPrimOp
1046    MutableByteArray# s -> Int#
1047    {Return the size of the array in bytes.}
1048
1049 primop IndexByteArrayOp_Char "indexCharArray#" GenPrimOp
1050    ByteArray# -> Int# -> Char#
1051    {Read 8-bit character; offset in bytes.}
1052    with can_fail = True
1053
1054 primop IndexByteArrayOp_WideChar "indexWideCharArray#" GenPrimOp
1055    ByteArray# -> Int# -> Char#
1056    {Read 31-bit character; offset in 4-byte words.}
1057    with can_fail = True
1058
1059 primop IndexByteArrayOp_Int "indexIntArray#" GenPrimOp
1060    ByteArray# -> Int# -> Int#
1061    with can_fail = True
1062
1063 primop IndexByteArrayOp_Word "indexWordArray#" GenPrimOp
1064    ByteArray# -> Int# -> Word#
1065    with can_fail = True
1066
1067 primop IndexByteArrayOp_Addr "indexAddrArray#" GenPrimOp
1068    ByteArray# -> Int# -> Addr#
1069    with can_fail = True
1070
1071 primop IndexByteArrayOp_Float "indexFloatArray#" GenPrimOp
1072    ByteArray# -> Int# -> Float#
1073    with can_fail = True
1074
1075 primop IndexByteArrayOp_Double "indexDoubleArray#" GenPrimOp
1076    ByteArray# -> Int# -> Double#
1077    with can_fail = True
1078
1079 primop IndexByteArrayOp_StablePtr "indexStablePtrArray#" GenPrimOp
1080    ByteArray# -> Int# -> StablePtr# a
1081    with can_fail = True
1082
1083 primop IndexByteArrayOp_Int8 "indexInt8Array#" GenPrimOp
1084    ByteArray# -> Int# -> Int#
1085    with can_fail = True
1086
1087 primop IndexByteArrayOp_Int16 "indexInt16Array#" GenPrimOp
1088    ByteArray# -> Int# -> Int#
1089    with can_fail = True
1090
1091 primop IndexByteArrayOp_Int32 "indexInt32Array#" GenPrimOp
1092    ByteArray# -> Int# -> INT32
1093    with can_fail = True
1094
1095 primop IndexByteArrayOp_Int64 "indexInt64Array#" GenPrimOp
1096    ByteArray# -> Int# -> INT64
1097    with can_fail = True
1098
1099 primop IndexByteArrayOp_Word8 "indexWord8Array#" GenPrimOp
1100    ByteArray# -> Int# -> Word#
1101    with can_fail = True
1102
1103 primop IndexByteArrayOp_Word16 "indexWord16Array#" GenPrimOp
1104    ByteArray# -> Int# -> Word#
1105    with can_fail = True
1106
1107 primop IndexByteArrayOp_Word32 "indexWord32Array#" GenPrimOp
1108    ByteArray# -> Int# -> WORD32
1109    with can_fail = True
1110
1111 primop IndexByteArrayOp_Word64 "indexWord64Array#" GenPrimOp
1112    ByteArray# -> Int# -> WORD64
1113    with can_fail = True
1114
1115 primop  ReadByteArrayOp_Char "readCharArray#" GenPrimOp
1116    MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
1117    {Read 8-bit character; offset in bytes.}
1118    with has_side_effects = True
1119         can_fail = True
1120
1121 primop  ReadByteArrayOp_WideChar "readWideCharArray#" GenPrimOp
1122    MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
1123    {Read 31-bit character; offset in 4-byte words.}
1124    with has_side_effects = True
1125         can_fail = True
1126
1127 primop  ReadByteArrayOp_Int "readIntArray#" GenPrimOp
1128    MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
1129    with has_side_effects = True
1130         can_fail = True
1131
1132 primop  ReadByteArrayOp_Word "readWordArray#" GenPrimOp
1133    MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
1134    with has_side_effects = True
1135         can_fail = True
1136
1137 primop  ReadByteArrayOp_Addr "readAddrArray#" GenPrimOp
1138    MutableByteArray# s -> Int# -> State# s -> (# State# s, Addr# #)
1139    with has_side_effects = True
1140         can_fail = True
1141
1142 primop  ReadByteArrayOp_Float "readFloatArray#" GenPrimOp
1143    MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
1144    with has_side_effects = True
1145         can_fail = True
1146
1147 primop  ReadByteArrayOp_Double "readDoubleArray#" GenPrimOp
1148    MutableByteArray# s -> Int# -> State# s -> (# State# s, Double# #)
1149    with has_side_effects = True
1150         can_fail = True
1151
1152 primop  ReadByteArrayOp_StablePtr "readStablePtrArray#" GenPrimOp
1153    MutableByteArray# s -> Int# -> State# s -> (# State# s, StablePtr# a #)
1154    with has_side_effects = True
1155         can_fail = True
1156
1157 primop  ReadByteArrayOp_Int8 "readInt8Array#" GenPrimOp
1158    MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
1159    with has_side_effects = True
1160         can_fail = True
1161
1162 primop  ReadByteArrayOp_Int16 "readInt16Array#" GenPrimOp
1163    MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
1164    with has_side_effects = True
1165         can_fail = True
1166
1167 primop  ReadByteArrayOp_Int32 "readInt32Array#" GenPrimOp
1168    MutableByteArray# s -> Int# -> State# s -> (# State# s, INT32 #)
1169    with has_side_effects = True
1170         can_fail = True
1171
1172 primop  ReadByteArrayOp_Int64 "readInt64Array#" GenPrimOp
1173    MutableByteArray# s -> Int# -> State# s -> (# State# s, INT64 #)
1174    with has_side_effects = True
1175         can_fail = True
1176
1177 primop  ReadByteArrayOp_Word8 "readWord8Array#" GenPrimOp
1178    MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
1179    with has_side_effects = True
1180         can_fail = True
1181
1182 primop  ReadByteArrayOp_Word16 "readWord16Array#" GenPrimOp
1183    MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
1184    with has_side_effects = True
1185         can_fail = True
1186
1187 primop  ReadByteArrayOp_Word32 "readWord32Array#" GenPrimOp
1188    MutableByteArray# s -> Int# -> State# s -> (# State# s, WORD32 #)
1189    with has_side_effects = True
1190         can_fail = True
1191
1192 primop  ReadByteArrayOp_Word64 "readWord64Array#" GenPrimOp
1193    MutableByteArray# s -> Int# -> State# s -> (# State# s, WORD64 #)
1194    with has_side_effects = True
1195         can_fail = True
1196
1197 primop  WriteByteArrayOp_Char "writeCharArray#" GenPrimOp
1198    MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
1199    {Write 8-bit character; offset in bytes.}
1200    with has_side_effects = True
1201         can_fail = True
1202
1203 primop  WriteByteArrayOp_WideChar "writeWideCharArray#" GenPrimOp
1204    MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
1205    {Write 31-bit character; offset in 4-byte words.}
1206    with has_side_effects = True
1207         can_fail = True
1208
1209 primop  WriteByteArrayOp_Int "writeIntArray#" GenPrimOp
1210    MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
1211    with has_side_effects = True
1212         can_fail = True
1213
1214 primop  WriteByteArrayOp_Word "writeWordArray#" GenPrimOp
1215    MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
1216    with has_side_effects = True
1217         can_fail = True
1218
1219 primop  WriteByteArrayOp_Addr "writeAddrArray#" GenPrimOp
1220    MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
1221    with has_side_effects = True
1222         can_fail = True
1223
1224 primop  WriteByteArrayOp_Float "writeFloatArray#" GenPrimOp
1225    MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
1226    with has_side_effects = True
1227         can_fail = True
1228
1229 primop  WriteByteArrayOp_Double "writeDoubleArray#" GenPrimOp
1230    MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
1231    with has_side_effects = True
1232         can_fail = True
1233
1234 primop  WriteByteArrayOp_StablePtr "writeStablePtrArray#" GenPrimOp
1235    MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
1236    with has_side_effects = True
1237         can_fail = True
1238
1239 primop  WriteByteArrayOp_Int8 "writeInt8Array#" GenPrimOp
1240    MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
1241    with has_side_effects = True
1242         can_fail = True
1243
1244 primop  WriteByteArrayOp_Int16 "writeInt16Array#" GenPrimOp
1245    MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
1246    with has_side_effects = True
1247         can_fail = True
1248
1249 primop  WriteByteArrayOp_Int32 "writeInt32Array#" GenPrimOp
1250    MutableByteArray# s -> Int# -> INT32 -> State# s -> State# s
1251    with has_side_effects = True
1252         can_fail = True
1253
1254 primop  WriteByteArrayOp_Int64 "writeInt64Array#" GenPrimOp
1255    MutableByteArray# s -> Int# -> INT64 -> State# s -> State# s
1256    with can_fail = True
1257         has_side_effects = True
1258
1259 primop  WriteByteArrayOp_Word8 "writeWord8Array#" GenPrimOp
1260    MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
1261    with has_side_effects = True
1262         can_fail = True
1263
1264 primop  WriteByteArrayOp_Word16 "writeWord16Array#" GenPrimOp
1265    MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
1266    with has_side_effects = True
1267         can_fail = True
1268
1269 primop  WriteByteArrayOp_Word32 "writeWord32Array#" GenPrimOp
1270    MutableByteArray# s -> Int# -> WORD32 -> State# s -> State# s
1271    with has_side_effects = True
1272         can_fail = True
1273
1274 primop  WriteByteArrayOp_Word64 "writeWord64Array#" GenPrimOp
1275    MutableByteArray# s -> Int# -> WORD64 -> State# s -> State# s
1276    with has_side_effects = True
1277         can_fail = True
1278
1279 primop  CopyByteArrayOp "copyByteArray#" GenPrimOp
1280   ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
1281   {Copy a range of the ByteArray# to the specified region in the MutableByteArray#.
1282    Both arrays must fully contain the specified ranges, but this is not checked.
1283    The two arrays must not be the same array in different states, but this is not checked either.}
1284   with
1285   has_side_effects = True
1286   code_size = { primOpCodeSizeForeignCall + 4}
1287   can_fail = True
1288
1289 primop  CopyMutableByteArrayOp "copyMutableByteArray#" GenPrimOp
1290   MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
1291   {Copy a range of the first MutableByteArray# to the specified region in the second MutableByteArray#.
1292    Both arrays must fully contain the specified ranges, but this is not checked.}
1293   with
1294   has_side_effects = True
1295   code_size = { primOpCodeSizeForeignCall + 4 }
1296   can_fail = True
1297
1298 primop  CopyByteArrayToAddrOp "copyByteArrayToAddr#" GenPrimOp
1299   ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s
1300   {Copy a range of the ByteArray# to the memory range starting at the Addr#.
1301    The ByteArray# and the memory region at Addr# must fully contain the
1302    specified ranges, but this is not checked. The Addr# must not point into the
1303    ByteArray# (e.g. if the ByteArray# were pinned), but this is not checked
1304    either.}
1305   with
1306   has_side_effects = True
1307   code_size = { primOpCodeSizeForeignCall + 4}
1308   can_fail = True
1309
1310 primop  CopyMutableByteArrayToAddrOp "copyMutableByteArrayToAddr#" GenPrimOp
1311   MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s
1312   {Copy a range of the MutableByteArray# to the memory range starting at the
1313    Addr#. The MutableByteArray# and the memory region at Addr# must fully
1314    contain the specified ranges, but this is not checked. The Addr# must not
1315    point into the MutableByteArray# (e.g. if the MutableByteArray# were
1316    pinned), but this is not checked either.}
1317   with
1318   has_side_effects = True
1319   code_size = { primOpCodeSizeForeignCall + 4}
1320   can_fail = True
1321
1322 primop  CopyAddrToByteArrayOp "copyAddrToByteArray#" GenPrimOp
1323   Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
1324   {Copy a memory range starting at the Addr# to the specified range in the
1325    MutableByteArray#. The memory region at Addr# and the ByteArray# must fully
1326    contain the specified ranges, but this is not checked. The Addr# must not
1327    point into the MutableByteArray# (e.g. if the MutableByteArray# were pinned),
1328    but this is not checked either.}
1329   with
1330   has_side_effects = True
1331   code_size = { primOpCodeSizeForeignCall + 4}
1332   can_fail = True
1333
1334 primop  SetByteArrayOp "setByteArray#" GenPrimOp
1335   MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s
1336   {Set the range of the MutableByteArray# to the specified character.}
1337   with
1338   has_side_effects = True
1339   code_size = { primOpCodeSizeForeignCall + 4 }
1340   can_fail = True
1341
1342 primop CasByteArrayOp_Int "casIntArray#" GenPrimOp
1343    MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s, Int# #)
1344    {Machine-level atomic compare and swap on a word within a ByteArray.}
1345    with
1346    out_of_line = True
1347    has_side_effects = True
1348
1349 primop FetchAddByteArrayOp_Int "fetchAddIntArray#" GenPrimOp
1350    MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
1351    {Machine-level word-sized fetch-and-add within a ByteArray.}
1352    with
1353    out_of_line = True
1354    has_side_effects = True
1355
1356
1357 ------------------------------------------------------------------------
1358 section "Arrays of arrays"
1359         {Operations on {\tt ArrayArray\#}. An {\tt ArrayArray\#} contains references to {\em unpointed}
1360          arrays, such as {\tt ByteArray\#s}. Hence, it is not parameterised by the element types,
1361          just like a {\tt ByteArray\#}, but it needs to be scanned during GC, just like an {\tt Array#}.
1362          We represent an {\tt ArrayArray\#} exactly as a {\tt Array\#}, but provide element-type-specific
1363          indexing, reading, and writing.}
1364 ------------------------------------------------------------------------
1365
1366 primtype ArrayArray#
1367
1368 primtype MutableArrayArray# s
1369
1370 primop  NewArrayArrayOp "newArrayArray#" GenPrimOp
1371    Int# -> State# s -> (# State# s, MutableArrayArray# s #)
1372    {Create a new mutable array of arrays with the specified number of elements,
1373     in the specified state thread, with each element recursively referring to the
1374     newly created array.}
1375    with
1376    out_of_line = True
1377    has_side_effects = True
1378
1379 primop  SameMutableArrayArrayOp "sameMutableArrayArray#" GenPrimOp
1380    MutableArrayArray# s -> MutableArrayArray# s -> Int#
1381
1382 primop  UnsafeFreezeArrayArrayOp "unsafeFreezeArrayArray#" GenPrimOp
1383    MutableArrayArray# s -> State# s -> (# State# s, ArrayArray# #)
1384    {Make a mutable array of arrays immutable, without copying.}
1385    with
1386    has_side_effects = True
1387
1388 primop  SizeofArrayArrayOp "sizeofArrayArray#" GenPrimOp
1389    ArrayArray# -> Int#
1390    {Return the number of elements in the array.}
1391
1392 primop  SizeofMutableArrayArrayOp "sizeofMutableArrayArray#" GenPrimOp
1393    MutableArrayArray# s -> Int#
1394    {Return the number of elements in the array.}
1395
1396 primop IndexArrayArrayOp_ByteArray "indexByteArrayArray#" GenPrimOp
1397    ArrayArray# -> Int# -> ByteArray#
1398    with can_fail = True
1399
1400 primop IndexArrayArrayOp_ArrayArray "indexArrayArrayArray#" GenPrimOp
1401    ArrayArray# -> Int# -> ArrayArray#
1402    with can_fail = True
1403
1404 primop  ReadArrayArrayOp_ByteArray "readByteArrayArray#" GenPrimOp
1405    MutableArrayArray# s -> Int# -> State# s -> (# State# s, ByteArray# #)
1406    with has_side_effects = True
1407         can_fail = True
1408
1409 primop  ReadArrayArrayOp_MutableByteArray "readMutableByteArrayArray#" GenPrimOp
1410    MutableArrayArray# s -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
1411    with has_side_effects = True
1412         can_fail = True
1413
1414 primop  ReadArrayArrayOp_ArrayArray "readArrayArrayArray#" GenPrimOp
1415    MutableArrayArray# s -> Int# -> State# s -> (# State# s, ArrayArray# #)
1416    with has_side_effects = True
1417         can_fail = True
1418
1419 primop  ReadArrayArrayOp_MutableArrayArray "readMutableArrayArrayArray#" GenPrimOp
1420    MutableArrayArray# s -> Int# -> State# s -> (# State# s, MutableArrayArray# s #)
1421    with has_side_effects = True
1422         can_fail = True
1423
1424 primop  WriteArrayArrayOp_ByteArray "writeByteArrayArray#" GenPrimOp
1425    MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s
1426    with has_side_effects = True
1427         can_fail = True
1428
1429 primop  WriteArrayArrayOp_MutableByteArray "writeMutableByteArrayArray#" GenPrimOp
1430    MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s
1431    with has_side_effects = True
1432         can_fail = True
1433
1434 primop  WriteArrayArrayOp_ArrayArray "writeArrayArrayArray#" GenPrimOp
1435    MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s
1436    with has_side_effects = True
1437         can_fail = True
1438
1439 primop  WriteArrayArrayOp_MutableArrayArray "writeMutableArrayArrayArray#" GenPrimOp
1440    MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s
1441    with has_side_effects = True
1442         can_fail = True
1443
1444 primop  CopyArrayArrayOp "copyArrayArray#" GenPrimOp
1445   ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
1446   {Copy a range of the ArrayArray# to the specified region in the MutableArrayArray#.
1447    Both arrays must fully contain the specified ranges, but this is not checked.
1448    The two arrays must not be the same array in different states, but this is not checked either.}
1449   with
1450   out_of_line      = True
1451   has_side_effects = True
1452   can_fail         = True
1453
1454 primop  CopyMutableArrayArrayOp "copyMutableArrayArray#" GenPrimOp
1455   MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
1456   {Copy a range of the first MutableArrayArray# to the specified region in the second
1457    MutableArrayArray#.
1458    Both arrays must fully contain the specified ranges, but this is not checked.}
1459   with
1460   out_of_line      = True
1461   has_side_effects = True
1462   can_fail         = True
1463
1464 ------------------------------------------------------------------------
1465 section "Addr#"
1466 ------------------------------------------------------------------------
1467
1468 primtype Addr#
1469         { An arbitrary machine address assumed to point outside
1470          the garbage-collected heap. }
1471
1472 pseudoop "nullAddr#" Addr#
1473         { The null address. }
1474
1475 primop   AddrAddOp "plusAddr#" GenPrimOp Addr# -> Int# -> Addr#
1476 primop   AddrSubOp "minusAddr#" GenPrimOp Addr# -> Addr# -> Int#
1477          {Result is meaningless if two {\tt Addr\#}s are so far apart that their
1478          difference doesn't fit in an {\tt Int\#}.}
1479 primop   AddrRemOp "remAddr#" GenPrimOp Addr# -> Int# -> Int#
1480          {Return the remainder when the {\tt Addr\#} arg, treated like an {\tt Int\#},
1481           is divided by the {\tt Int\#} arg.}
1482 #if (WORD_SIZE_IN_BITS == 32 || WORD_SIZE_IN_BITS == 64)
1483 primop   Addr2IntOp  "addr2Int#"     GenPrimOp   Addr# -> Int#
1484         {Coerce directly from address to int. Strongly deprecated.}
1485    with code_size = 0
1486 primop   Int2AddrOp   "int2Addr#"    GenPrimOp  Int# -> Addr#
1487         {Coerce directly from int to address. Strongly deprecated.}
1488    with code_size = 0
1489 #endif
1490
1491 primop   AddrGtOp  "gtAddr#"   Compare   Addr# -> Addr# -> Int#
1492 primop   AddrGeOp  "geAddr#"   Compare   Addr# -> Addr# -> Int#
1493 primop   AddrEqOp  "eqAddr#"   Compare   Addr# -> Addr# -> Int#
1494 primop   AddrNeOp  "neAddr#"   Compare   Addr# -> Addr# -> Int#
1495 primop   AddrLtOp  "ltAddr#"   Compare   Addr# -> Addr# -> Int#
1496 primop   AddrLeOp  "leAddr#"   Compare   Addr# -> Addr# -> Int#
1497
1498 primop IndexOffAddrOp_Char "indexCharOffAddr#" GenPrimOp
1499    Addr# -> Int# -> Char#
1500    {Reads 8-bit character; offset in bytes.}
1501    with can_fail = True
1502
1503 primop IndexOffAddrOp_WideChar "indexWideCharOffAddr#" GenPrimOp
1504    Addr# -> Int# -> Char#
1505    {Reads 31-bit character; offset in 4-byte words.}
1506    with can_fail = True
1507
1508 primop IndexOffAddrOp_Int "indexIntOffAddr#" GenPrimOp
1509    Addr# -> Int# -> Int#
1510    with can_fail = True
1511
1512 primop IndexOffAddrOp_Word "indexWordOffAddr#" GenPrimOp
1513    Addr# -> Int# -> Word#
1514    with can_fail = True
1515
1516 primop IndexOffAddrOp_Addr "indexAddrOffAddr#" GenPrimOp
1517    Addr# -> Int# -> Addr#
1518    with can_fail = True
1519
1520 primop IndexOffAddrOp_Float "indexFloatOffAddr#" GenPrimOp
1521    Addr# -> Int# -> Float#
1522    with can_fail = True
1523
1524 primop IndexOffAddrOp_Double "indexDoubleOffAddr#" GenPrimOp
1525    Addr# -> Int# -> Double#
1526    with can_fail = True
1527
1528 primop IndexOffAddrOp_StablePtr "indexStablePtrOffAddr#" GenPrimOp
1529    Addr# -> Int# -> StablePtr# a
1530    with can_fail = True
1531
1532 primop IndexOffAddrOp_Int8 "indexInt8OffAddr#" GenPrimOp
1533    Addr# -> Int# -> Int#
1534    with can_fail = True
1535
1536 primop IndexOffAddrOp_Int16 "indexInt16OffAddr#" GenPrimOp
1537    Addr# -> Int# -> Int#
1538    with can_fail = True
1539
1540 primop IndexOffAddrOp_Int32 "indexInt32OffAddr#" GenPrimOp
1541    Addr# -> Int# -> INT32
1542    with can_fail = True
1543
1544 primop IndexOffAddrOp_Int64 "indexInt64OffAddr#" GenPrimOp
1545    Addr# -> Int# -> INT64
1546    with can_fail = True
1547
1548 primop IndexOffAddrOp_Word8 "indexWord8OffAddr#" GenPrimOp
1549    Addr# -> Int# -> Word#
1550    with can_fail = True
1551
1552 primop IndexOffAddrOp_Word16 "indexWord16OffAddr#" GenPrimOp
1553    Addr# -> Int# -> Word#
1554    with can_fail = True
1555
1556 primop IndexOffAddrOp_Word32 "indexWord32OffAddr#" GenPrimOp
1557    Addr# -> Int# -> WORD32
1558    with can_fail = True
1559
1560 primop IndexOffAddrOp_Word64 "indexWord64OffAddr#" GenPrimOp
1561    Addr# -> Int# -> WORD64
1562    with can_fail = True
1563
1564 primop ReadOffAddrOp_Char "readCharOffAddr#" GenPrimOp
1565    Addr# -> Int# -> State# s -> (# State# s, Char# #)
1566    {Reads 8-bit character; offset in bytes.}
1567    with has_side_effects = True
1568         can_fail         = True
1569
1570 primop ReadOffAddrOp_WideChar "readWideCharOffAddr#" GenPrimOp
1571    Addr# -> Int# -> State# s -> (# State# s, Char# #)
1572    {Reads 31-bit character; offset in 4-byte words.}
1573    with has_side_effects = True
1574         can_fail         = True
1575
1576 primop ReadOffAddrOp_Int "readIntOffAddr#" GenPrimOp
1577    Addr# -> Int# -> State# s -> (# State# s, Int# #)
1578    with has_side_effects = True
1579         can_fail         = True
1580
1581 primop ReadOffAddrOp_Word "readWordOffAddr#" GenPrimOp
1582    Addr# -> Int# -> State# s -> (# State# s, Word# #)
1583    with has_side_effects = True
1584         can_fail         = True
1585
1586 primop ReadOffAddrOp_Addr "readAddrOffAddr#" GenPrimOp
1587    Addr# -> Int# -> State# s -> (# State# s, Addr# #)
1588    with has_side_effects = True
1589         can_fail         = True
1590
1591 primop ReadOffAddrOp_Float "readFloatOffAddr#" GenPrimOp
1592    Addr# -> Int# -> State# s -> (# State# s, Float# #)
1593    with has_side_effects = True
1594         can_fail         = True
1595
1596 primop ReadOffAddrOp_Double "readDoubleOffAddr#" GenPrimOp
1597    Addr# -> Int# -> State# s -> (# State# s, Double# #)
1598    with has_side_effects = True
1599         can_fail         = True
1600
1601 primop ReadOffAddrOp_StablePtr "readStablePtrOffAddr#" GenPrimOp
1602    Addr# -> Int# -> State# s -> (# State# s, StablePtr# a #)
1603    with has_side_effects = True
1604         can_fail         = True
1605
1606 primop ReadOffAddrOp_Int8 "readInt8OffAddr#" GenPrimOp
1607    Addr# -> Int# -> State# s -> (# State# s, Int# #)
1608    with has_side_effects = True
1609         can_fail         = True
1610
1611 primop ReadOffAddrOp_Int16 "readInt16OffAddr#" GenPrimOp
1612    Addr# -> Int# -> State# s -> (# State# s, Int# #)
1613    with has_side_effects = True
1614         can_fail         = True
1615
1616 primop ReadOffAddrOp_Int32 "readInt32OffAddr#" GenPrimOp
1617    Addr# -> Int# -> State# s -> (# State# s, INT32 #)
1618    with has_side_effects = True
1619         can_fail         = True
1620
1621 primop ReadOffAddrOp_Int64 "readInt64OffAddr#" GenPrimOp
1622    Addr# -> Int# -> State# s -> (# State# s, INT64 #)
1623    with has_side_effects = True
1624         can_fail         = True
1625
1626 primop ReadOffAddrOp_Word8 "readWord8OffAddr#" GenPrimOp
1627    Addr# -> Int# -> State# s -> (# State# s, Word# #)
1628    with has_side_effects = True
1629         can_fail         = True
1630
1631 primop ReadOffAddrOp_Word16 "readWord16OffAddr#" GenPrimOp
1632    Addr# -> Int# -> State# s -> (# State# s, Word# #)
1633    with has_side_effects = True
1634         can_fail         = True
1635
1636 primop ReadOffAddrOp_Word32 "readWord32OffAddr#" GenPrimOp
1637    Addr# -> Int# -> State# s -> (# State# s, WORD32 #)
1638    with has_side_effects = True
1639         can_fail         = True
1640
1641 primop ReadOffAddrOp_Word64 "readWord64OffAddr#" GenPrimOp
1642    Addr# -> Int# -> State# s -> (# State# s, WORD64 #)
1643    with has_side_effects = True
1644         can_fail         = True
1645
1646 primop  WriteOffAddrOp_Char "writeCharOffAddr#" GenPrimOp
1647    Addr# -> Int# -> Char# -> State# s -> State# s
1648    with has_side_effects = True
1649         can_fail         = True
1650
1651 primop  WriteOffAddrOp_WideChar "writeWideCharOffAddr#" GenPrimOp
1652    Addr# -> Int# -> Char# -> State# s -> State# s
1653    with has_side_effects = True
1654         can_fail         = True
1655
1656 primop  WriteOffAddrOp_Int "writeIntOffAddr#" GenPrimOp
1657    Addr# -> Int# -> Int# -> State# s -> State# s
1658    with has_side_effects = True
1659         can_fail         = True
1660
1661 primop  WriteOffAddrOp_Word "writeWordOffAddr#" GenPrimOp
1662    Addr# -> Int# -> Word# -> State# s -> State# s
1663    with has_side_effects = True
1664         can_fail         = True
1665
1666 primop  WriteOffAddrOp_Addr "writeAddrOffAddr#" GenPrimOp
1667    Addr# -> Int# -> Addr# -> State# s -> State# s
1668    with has_side_effects = True
1669         can_fail         = True
1670
1671 primop  WriteOffAddrOp_Float "writeFloatOffAddr#" GenPrimOp
1672    Addr# -> Int# -> Float# -> State# s -> State# s
1673    with has_side_effects = True
1674         can_fail         = True
1675
1676 primop  WriteOffAddrOp_Double "writeDoubleOffAddr#" GenPrimOp
1677    Addr# -> Int# -> Double# -> State# s -> State# s
1678    with has_side_effects = True
1679         can_fail         = True
1680
1681 primop  WriteOffAddrOp_StablePtr "writeStablePtrOffAddr#" GenPrimOp
1682    Addr# -> Int# -> StablePtr# a -> State# s -> State# s
1683    with has_side_effects = True
1684         can_fail         = True
1685
1686 primop  WriteOffAddrOp_Int8 "writeInt8OffAddr#" GenPrimOp
1687    Addr# -> Int# -> Int# -> State# s -> State# s
1688    with has_side_effects = True
1689         can_fail         = True
1690
1691 primop  WriteOffAddrOp_Int16 "writeInt16OffAddr#" GenPrimOp
1692    Addr# -> Int# -> Int# -> State# s -> State# s
1693    with has_side_effects = True
1694         can_fail         = True
1695
1696 primop  WriteOffAddrOp_Int32 "writeInt32OffAddr#" GenPrimOp
1697    Addr# -> Int# -> INT32 -> State# s -> State# s
1698    with has_side_effects = True
1699         can_fail         = True
1700
1701 primop  WriteOffAddrOp_Int64 "writeInt64OffAddr#" GenPrimOp
1702    Addr# -> Int# -> INT64 -> State# s -> State# s
1703    with has_side_effects = True
1704         can_fail         = True
1705
1706 primop  WriteOffAddrOp_Word8 "writeWord8OffAddr#" GenPrimOp
1707    Addr# -> Int# -> Word# -> State# s -> State# s
1708    with has_side_effects = True
1709         can_fail         = True
1710
1711 primop  WriteOffAddrOp_Word16 "writeWord16OffAddr#" GenPrimOp
1712    Addr# -> Int# -> Word# -> State# s -> State# s
1713    with has_side_effects = True
1714         can_fail         = True
1715
1716 primop  WriteOffAddrOp_Word32 "writeWord32OffAddr#" GenPrimOp
1717    Addr# -> Int# -> WORD32 -> State# s -> State# s
1718    with has_side_effects = True
1719         can_fail         = True
1720
1721 primop  WriteOffAddrOp_Word64 "writeWord64OffAddr#" GenPrimOp
1722    Addr# -> Int# -> WORD64 -> State# s -> State# s
1723    with has_side_effects = True
1724         can_fail         = True
1725
1726 ------------------------------------------------------------------------
1727 section "Mutable variables"
1728         {Operations on MutVar\#s.}
1729 ------------------------------------------------------------------------
1730
1731 primtype MutVar# s a
1732         {A {\tt MutVar\#} behaves like a single-element mutable array.}
1733
1734 primop  NewMutVarOp "newMutVar#" GenPrimOp
1735    a -> State# s -> (# State# s, MutVar# s a #)
1736    {Create {\tt MutVar\#} with specified initial value in specified state thread.}
1737    with
1738    out_of_line = True
1739    has_side_effects = True
1740
1741 primop  ReadMutVarOp "readMutVar#" GenPrimOp
1742    MutVar# s a -> State# s -> (# State# s, a #)
1743    {Read contents of {\tt MutVar\#}. Result is not yet evaluated.}
1744    with
1745    has_side_effects = True
1746    can_fail         = True
1747
1748 primop  WriteMutVarOp "writeMutVar#"  GenPrimOp
1749    MutVar# s a -> a -> State# s -> State# s
1750    {Write contents of {\tt MutVar\#}.}
1751    with
1752    has_side_effects = True
1753    code_size = { primOpCodeSizeForeignCall } -- for the write barrier
1754    can_fail         = True
1755
1756 primop  SameMutVarOp "sameMutVar#" GenPrimOp
1757    MutVar# s a -> MutVar# s a -> Int#
1758
1759 -- not really the right type, but we don't know about pairs here.  The
1760 -- correct type is
1761 --
1762 --   MutVar# s a -> (a -> (a,b)) -> State# s -> (# State# s, b #)
1763 --
1764 primop  AtomicModifyMutVarOp "atomicModifyMutVar#" GenPrimOp
1765    MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
1766    with
1767    out_of_line = True
1768    has_side_effects = True
1769    can_fail         = True
1770
1771 primop  CasMutVarOp "casMutVar#" GenPrimOp
1772   MutVar# s a -> a -> a -> State# s -> (# State# s, Int#, a #)
1773    with
1774    out_of_line = True
1775    has_side_effects = True
1776
1777 ------------------------------------------------------------------------
1778 section "Exceptions"
1779 ------------------------------------------------------------------------
1780
1781 primop  CatchOp "catch#" GenPrimOp
1782           (State# RealWorld -> (# State# RealWorld, a #) )
1783        -> (b -> State# RealWorld -> (# State# RealWorld, a #) )
1784        -> State# RealWorld
1785        -> (# State# RealWorld, a #)
1786    with
1787         -- Catch is actually strict in its first argument
1788         -- but we don't want to tell the strictness
1789         -- analyser about that, so that exceptions stay inside it.
1790    strictness  = { \ _arity -> mkClosedStrictSig [apply1Dmd,apply2Dmd,topDmd] topRes }
1791    out_of_line = True
1792    has_side_effects = True
1793
1794 primop  RaiseOp "raise#" GenPrimOp
1795    a -> b
1796    with
1797    strictness  = { \ _arity -> mkClosedStrictSig [topDmd] botRes }
1798       -- NB: result is bottom
1799    out_of_line = True
1800
1801 -- raiseIO# needs to be a primop, because exceptions in the IO monad
1802 -- must be *precise* - we don't want the strictness analyser turning
1803 -- one kind of bottom into another, as it is allowed to do in pure code.
1804 --
1805 -- But we *do* want to know that it returns bottom after
1806 -- being applied to two arguments, so that this function is strict in y
1807 --     f x y | x>0       = raiseIO blah
1808 --           | y>0       = return 1
1809 --           | otherwise = return 2
1810
1811 primop  RaiseIOOp "raiseIO#" GenPrimOp
1812    a -> State# RealWorld -> (# State# RealWorld, b #)
1813    with
1814    strictness  = { \ _arity -> mkClosedStrictSig [topDmd, topDmd] botRes }
1815    out_of_line = True
1816    has_side_effects = True
1817
1818 primop  MaskAsyncExceptionsOp "maskAsyncExceptions#" GenPrimOp
1819         (State# RealWorld -> (# State# RealWorld, a #))
1820      -> (State# RealWorld -> (# State# RealWorld, a #))
1821    with
1822    strictness  = { \ _arity -> mkClosedStrictSig [apply1Dmd,topDmd] topRes }
1823    out_of_line = True
1824    has_side_effects = True
1825
1826 primop  MaskUninterruptibleOp "maskUninterruptible#" GenPrimOp
1827         (State# RealWorld -> (# State# RealWorld, a #))
1828      -> (State# RealWorld -> (# State# RealWorld, a #))
1829    with
1830    strictness  = { \ _arity -> mkClosedStrictSig [apply1Dmd,topDmd] topRes }
1831    out_of_line = True
1832    has_side_effects = True
1833
1834 primop  UnmaskAsyncExceptionsOp "unmaskAsyncExceptions#" GenPrimOp
1835         (State# RealWorld -> (# State# RealWorld, a #))
1836      -> (State# RealWorld -> (# State# RealWorld, a #))
1837    with
1838    strictness  = { \ _arity -> mkClosedStrictSig [apply1Dmd,topDmd] topRes }
1839    out_of_line = True
1840    has_side_effects = True
1841
1842 primop  MaskStatus "getMaskingState#" GenPrimOp
1843         State# RealWorld -> (# State# RealWorld, Int# #)
1844    with
1845    out_of_line = True
1846    has_side_effects = True
1847
1848 ------------------------------------------------------------------------
1849 section "STM-accessible Mutable Variables"
1850 ------------------------------------------------------------------------
1851
1852 primtype TVar# s a
1853
1854 primop  AtomicallyOp "atomically#" GenPrimOp
1855       (State# RealWorld -> (# State# RealWorld, a #) )
1856    -> State# RealWorld -> (# State# RealWorld, a #)
1857    with
1858    strictness  = { \ _arity -> mkClosedStrictSig [apply1Dmd,topDmd] topRes }
1859    out_of_line = True
1860    has_side_effects = True
1861
1862 -- NB: retry#'s strictness information specifies it to return bottom.
1863 -- This lets the compiler perform some extra simplifications, since retry#
1864 -- will technically never return.
1865 --
1866 -- This allows the simplifier to replace things like:
1867 --   case retry# s1
1868 --     (# s2, a #) -> e
1869 -- with:
1870 --   retry# s1
1871 -- where 'e' would be unreachable anyway.  See Trac #8091.
1872 primop  RetryOp "retry#" GenPrimOp
1873    State# RealWorld -> (# State# RealWorld, a #)
1874    with
1875    strictness  = { \ _arity -> mkClosedStrictSig [topDmd] botRes }
1876    out_of_line = True
1877    has_side_effects = True
1878
1879 primop  CatchRetryOp "catchRetry#" GenPrimOp
1880       (State# RealWorld -> (# State# RealWorld, a #) )
1881    -> (State# RealWorld -> (# State# RealWorld, a #) )
1882    -> (State# RealWorld -> (# State# RealWorld, a #) )
1883    with
1884    strictness  = { \ _arity -> mkClosedStrictSig [apply1Dmd,apply1Dmd,topDmd] topRes }
1885    out_of_line = True
1886    has_side_effects = True
1887
1888 primop  CatchSTMOp "catchSTM#" GenPrimOp
1889       (State# RealWorld -> (# State# RealWorld, a #) )
1890    -> (b -> State# RealWorld -> (# State# RealWorld, a #) )
1891    -> (State# RealWorld -> (# State# RealWorld, a #) )
1892    with
1893    strictness  = { \ _arity -> mkClosedStrictSig [apply1Dmd,apply2Dmd,topDmd] topRes }
1894    out_of_line = True
1895    has_side_effects = True
1896
1897 primop  Check "check#" GenPrimOp
1898       (State# RealWorld -> (# State# RealWorld, a #) )
1899    -> (State# RealWorld -> (# State# RealWorld, () #) )
1900    with
1901    out_of_line = True
1902    has_side_effects = True
1903
1904 primop  NewTVarOp "newTVar#" GenPrimOp
1905        a
1906     -> State# s -> (# State# s, TVar# s a #)
1907    {Create a new {\tt TVar\#} holding a specified initial value.}
1908    with
1909    out_of_line  = True
1910    has_side_effects = True
1911
1912 primop  ReadTVarOp "readTVar#" GenPrimOp
1913        TVar# s a
1914     -> State# s -> (# State# s, a #)
1915    {Read contents of {\tt TVar\#}.  Result is not yet evaluated.}
1916    with
1917    out_of_line  = True
1918    has_side_effects = True
1919
1920 primop ReadTVarIOOp "readTVarIO#" GenPrimOp
1921        TVar# s a
1922     -> State# s -> (# State# s, a #)
1923    {Read contents of {\tt TVar\#} outside an STM transaction}
1924    with
1925    out_of_line  = True
1926    has_side_effects = True
1927
1928 primop  WriteTVarOp "writeTVar#" GenPrimOp
1929        TVar# s a
1930     -> a
1931     -> State# s -> State# s
1932    {Write contents of {\tt TVar\#}.}
1933    with
1934    out_of_line      = True
1935    has_side_effects = True
1936
1937 primop  SameTVarOp "sameTVar#" GenPrimOp
1938    TVar# s a -> TVar# s a -> Int#
1939
1940
1941 ------------------------------------------------------------------------
1942 section "Synchronized Mutable Variables"
1943         {Operations on {\tt MVar\#}s. }
1944 ------------------------------------------------------------------------
1945
1946 primtype MVar# s a
1947         { A shared mutable variable ({\it not} the same as a {\tt MutVar\#}!).
1948         (Note: in a non-concurrent implementation, {\tt (MVar\# a)} can be
1949         represented by {\tt (MutVar\# (Maybe a))}.) }
1950
1951 primop  NewMVarOp "newMVar#"  GenPrimOp
1952    State# s -> (# State# s, MVar# s a #)
1953    {Create new {\tt MVar\#}; initially empty.}
1954    with
1955    out_of_line = True
1956    has_side_effects = True
1957
1958 primop  TakeMVarOp "takeMVar#" GenPrimOp
1959    MVar# s a -> State# s -> (# State# s, a #)
1960    {If {\tt MVar\#} is empty, block until it becomes full.
1961    Then remove and return its contents, and set it empty.}
1962    with
1963    out_of_line      = True
1964    has_side_effects = True
1965
1966 primop  TryTakeMVarOp "tryTakeMVar#" GenPrimOp
1967    MVar# s a -> State# s -> (# State# s, Int#, a #)
1968    {If {\tt MVar\#} is empty, immediately return with integer 0 and value undefined.
1969    Otherwise, return with integer 1 and contents of {\tt MVar\#}, and set {\tt MVar\#} empty.}
1970    with
1971    out_of_line      = True
1972    has_side_effects = True
1973
1974 primop  PutMVarOp "putMVar#" GenPrimOp
1975    MVar# s a -> a -> State# s -> State# s
1976    {If {\tt MVar\#} is full, block until it becomes empty.
1977    Then store value arg as its new contents.}
1978    with
1979    out_of_line      = True
1980    has_side_effects = True
1981
1982 primop  TryPutMVarOp "tryPutMVar#" GenPrimOp
1983    MVar# s a -> a -> State# s -> (# State# s, Int# #)
1984    {If {\tt MVar\#} is full, immediately return with integer 0.
1985     Otherwise, store value arg as {\tt MVar\#}'s new contents, and return with integer 1.}
1986    with
1987    out_of_line      = True
1988    has_side_effects = True
1989
1990 primop  ReadMVarOp "readMVar#" GenPrimOp
1991    MVar# s a -> State# s -> (# State# s, a #)
1992    {If {\tt MVar\#} is empty, block until it becomes full.
1993    Then read its contents without modifying the MVar, without possibility
1994    of intervention from other threads.}
1995    with
1996    out_of_line      = True
1997    has_side_effects = True
1998
1999 primop  TryReadMVarOp "tryReadMVar#" GenPrimOp
2000    MVar# s a -> State# s -> (# State# s, Int#, a #)
2001    {If {\tt MVar\#} is empty, immediately return with integer 0 and value undefined.
2002    Otherwise, return with integer 1 and contents of {\tt MVar\#}.}
2003    with
2004    out_of_line      = True
2005    has_side_effects = True
2006
2007 primop  SameMVarOp "sameMVar#" GenPrimOp
2008    MVar# s a -> MVar# s a -> Int#
2009
2010 primop  IsEmptyMVarOp "isEmptyMVar#" GenPrimOp
2011    MVar# s a -> State# s -> (# State# s, Int# #)
2012    {Return 1 if {\tt MVar\#} is empty; 0 otherwise.}
2013    with
2014    out_of_line = True
2015    has_side_effects = True
2016
2017 ------------------------------------------------------------------------
2018 section "Delay/wait operations"
2019 ------------------------------------------------------------------------
2020
2021 primop  DelayOp "delay#" GenPrimOp
2022    Int# -> State# s -> State# s
2023    {Sleep specified number of microseconds.}
2024    with
2025    has_side_effects = True
2026    out_of_line      = True
2027
2028 primop  WaitReadOp "waitRead#" GenPrimOp
2029    Int# -> State# s -> State# s
2030    {Block until input is available on specified file descriptor.}
2031    with
2032    has_side_effects = True
2033    out_of_line      = True
2034
2035 primop  WaitWriteOp "waitWrite#" GenPrimOp
2036    Int# -> State# s -> State# s
2037    {Block until output is possible on specified file descriptor.}
2038    with
2039    has_side_effects = True
2040    out_of_line      = True
2041
2042 #ifdef mingw32_TARGET_OS
2043 primop  AsyncReadOp "asyncRead#" GenPrimOp
2044    Int# -> Int# -> Int# -> Addr# -> State# RealWorld-> (# State# RealWorld, Int#, Int# #)
2045    {Asynchronously read bytes from specified file descriptor.}
2046    with
2047    has_side_effects = True
2048    out_of_line      = True
2049
2050 primop  AsyncWriteOp "asyncWrite#" GenPrimOp
2051    Int# -> Int# -> Int# -> Addr# -> State# RealWorld-> (# State# RealWorld, Int#, Int# #)
2052    {Asynchronously write bytes from specified file descriptor.}
2053    with
2054    has_side_effects = True
2055    out_of_line      = True
2056
2057 primop  AsyncDoProcOp "asyncDoProc#" GenPrimOp
2058    Addr# -> Addr# -> State# RealWorld-> (# State# RealWorld, Int#, Int# #)
2059    {Asynchronously perform procedure (first arg), passing it 2nd arg.}
2060    with
2061    has_side_effects = True
2062    out_of_line      = True
2063
2064 #endif
2065
2066 ------------------------------------------------------------------------
2067 section "Concurrency primitives"
2068 ------------------------------------------------------------------------
2069
2070 primtype State# s
2071         { {\tt State\#} is the primitive, unlifted type of states.  It has
2072         one type parameter, thus {\tt State\# RealWorld}, or {\tt State\# s},
2073         where s is a type variable. The only purpose of the type parameter
2074         is to keep different state threads separate.  It is represented by
2075         nothing at all. }
2076
2077 primtype RealWorld
2078         { {\tt RealWorld} is deeply magical.  It is {\it primitive}, but it is not
2079         {\it unlifted} (hence {\tt ptrArg}).  We never manipulate values of type
2080         {\tt RealWorld}; it's only used in the type system, to parameterise {\tt State\#}. }
2081
2082 primtype ThreadId#
2083         {(In a non-concurrent implementation, this can be a singleton
2084         type, whose (unique) value is returned by {\tt myThreadId\#}.  The
2085         other operations can be omitted.)}
2086
2087 primop  ForkOp "fork#" GenPrimOp
2088    a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
2089    with
2090    has_side_effects = True
2091    out_of_line      = True
2092
2093 primop  ForkOnOp "forkOn#" GenPrimOp
2094    Int# -> a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
2095    with
2096    has_side_effects = True
2097    out_of_line      = True
2098
2099 primop  KillThreadOp "killThread#"  GenPrimOp
2100    ThreadId# -> a -> State# RealWorld -> State# RealWorld
2101    with
2102    has_side_effects = True
2103    out_of_line      = True
2104
2105 primop  YieldOp "yield#" GenPrimOp
2106    State# RealWorld -> State# RealWorld
2107    with
2108    has_side_effects = True
2109    out_of_line      = True
2110
2111 primop  MyThreadIdOp "myThreadId#" GenPrimOp
2112    State# RealWorld -> (# State# RealWorld, ThreadId# #)
2113    with
2114    out_of_line = True
2115    has_side_effects = True
2116
2117 primop LabelThreadOp "labelThread#" GenPrimOp
2118    ThreadId# -> Addr# -> State# RealWorld -> State# RealWorld
2119    with
2120    has_side_effects = True
2121    out_of_line      = True
2122
2123 primop  IsCurrentThreadBoundOp "isCurrentThreadBound#" GenPrimOp
2124    State# RealWorld -> (# State# RealWorld, Int# #)
2125    with
2126    out_of_line = True
2127    has_side_effects = True
2128
2129 primop  NoDuplicateOp "noDuplicate#" GenPrimOp
2130    State# RealWorld -> State# RealWorld
2131    with
2132    out_of_line = True
2133    has_side_effects = True
2134
2135 primop  ThreadStatusOp "threadStatus#" GenPrimOp
2136    ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, Int#, Int# #)
2137    with
2138    out_of_line = True
2139    has_side_effects = True
2140
2141 ------------------------------------------------------------------------
2142 section "Weak pointers"
2143 ------------------------------------------------------------------------
2144
2145 primtype Weak# b
2146
2147 -- note that tyvar "o" denotes openAlphaTyVar
2148
2149 primop  MkWeakOp "mkWeak#" GenPrimOp
2150    o -> b -> c -> State# RealWorld -> (# State# RealWorld, Weak# b #)
2151    with
2152    has_side_effects = True
2153    out_of_line      = True
2154
2155 primop  MkWeakNoFinalizerOp "mkWeakNoFinalizer#" GenPrimOp
2156    o -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)
2157    with
2158    has_side_effects = True
2159    out_of_line      = True
2160
2161 primop  AddCFinalizerToWeakOp "addCFinalizerToWeak#" GenPrimOp
2162    Addr# -> Addr# -> Int# -> Addr# -> Weak# b
2163           -> State# RealWorld -> (# State# RealWorld, Int# #)
2164    { {\tt addCFinalizerToWeak# fptr ptr flag eptr w} attaches a C
2165      function pointer {\tt fptr} to a weak pointer {\tt w} as a finalizer. If
2166      {\tt flag} is zero, {\tt fptr} will be called with one argument,
2167      {\tt ptr}. Otherwise, it will be called with two arguments,
2168      {\tt eptr} and {\tt ptr}. {\tt addCFinalizerToWeak#} returns
2169      1 on success, or 0 if {\tt w} is already dead. }
2170    with
2171    has_side_effects = True
2172    out_of_line      = True
2173
2174 primop  DeRefWeakOp "deRefWeak#" GenPrimOp
2175    Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)
2176    with
2177    has_side_effects = True
2178    out_of_line      = True
2179
2180 primop  FinalizeWeakOp "finalizeWeak#" GenPrimOp
2181    Weak# a -> State# RealWorld -> (# State# RealWorld, Int#,
2182               (State# RealWorld -> (# State# RealWorld, () #)) #)
2183    with
2184    has_side_effects = True
2185    out_of_line      = True
2186
2187 primop TouchOp "touch#" GenPrimOp
2188    o -> State# RealWorld -> State# RealWorld
2189    with
2190    code_size = { 0 }
2191    has_side_effects = True
2192
2193 ------------------------------------------------------------------------
2194 section "Stable pointers and names"
2195 ------------------------------------------------------------------------
2196
2197 primtype StablePtr# a
2198
2199 primtype StableName# a
2200
2201 primop  MakeStablePtrOp "makeStablePtr#" GenPrimOp
2202    a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
2203    with
2204    has_side_effects = True
2205    out_of_line      = True
2206
2207 primop  DeRefStablePtrOp "deRefStablePtr#" GenPrimOp
2208    StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
2209    with
2210    has_side_effects = True
2211    out_of_line      = True
2212
2213 primop  EqStablePtrOp "eqStablePtr#" GenPrimOp
2214    StablePtr# a -> StablePtr# a -> Int#
2215    with
2216    has_side_effects = True
2217
2218 primop  MakeStableNameOp "makeStableName#" GenPrimOp
2219    a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
2220    with
2221    has_side_effects = True
2222    out_of_line      = True
2223
2224 primop  EqStableNameOp "eqStableName#" GenPrimOp
2225    StableName# a -> StableName# b -> Int#
2226
2227 primop  StableNameToIntOp "stableNameToInt#" GenPrimOp
2228    StableName# a -> Int#
2229
2230 ------------------------------------------------------------------------
2231 section "Unsafe pointer equality"
2232 --  (#1 Bad Guy: Alistair Reid :)
2233 ------------------------------------------------------------------------
2234
2235 primop  ReallyUnsafePtrEqualityOp "reallyUnsafePtrEquality#" GenPrimOp
2236    a -> a -> Int#
2237
2238 ------------------------------------------------------------------------
2239 section "Parallelism"
2240 ------------------------------------------------------------------------
2241
2242 primop  ParOp "par#" GenPrimOp
2243    a -> Int#
2244    with
2245       -- Note that Par is lazy to avoid that the sparked thing
2246       -- gets evaluted strictly, which it should *not* be
2247    has_side_effects = True
2248    code_size = { primOpCodeSizeForeignCall }
2249
2250 primop SparkOp "spark#" GenPrimOp
2251    a -> State# s -> (# State# s, a #)
2252    with has_side_effects = True
2253    code_size = { primOpCodeSizeForeignCall }
2254
2255 primop SeqOp "seq#" GenPrimOp
2256    a -> State# s -> (# State# s, a #)
2257
2258    -- why return the value?  So that we can control sharing of seq'd
2259    -- values: in
2260    --    let x = e in x `seq` ... x ...
2261    -- we don't want to inline x, so better to represent it as
2262    --    let x = e in case seq# x RW of (# _, x' #) -> ... x' ...
2263    -- also it matches the type of rseq in the Eval monad.
2264
2265 primop GetSparkOp "getSpark#" GenPrimOp
2266    State# s -> (# State# s, Int#, a #)
2267    with
2268    has_side_effects = True
2269    out_of_line = True
2270
2271 primop NumSparks "numSparks#" GenPrimOp
2272    State# s -> (# State# s, Int# #)
2273    { Returns the number of sparks in the local spark pool. }
2274    with
2275    has_side_effects = True
2276    out_of_line = True
2277
2278 -- HWL: The first 4 Int# in all par... annotations denote:
2279 --   name, granularity info, size of result, degree of parallelism
2280 --      Same  structure as _seq_ i.e. returns Int#
2281 -- KSW: v, the second arg in parAt# and parAtForNow#, is used only to determine
2282 --   `the processor containing the expression v'; it is not evaluated
2283
2284 primop  ParGlobalOp  "parGlobal#"  GenPrimOp
2285    a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
2286    with
2287    has_side_effects = True
2288
2289 primop  ParLocalOp  "parLocal#"  GenPrimOp
2290    a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
2291    with
2292    has_side_effects = True
2293
2294 primop  ParAtOp  "parAt#"  GenPrimOp
2295    b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
2296    with
2297    has_side_effects = True
2298
2299 primop  ParAtAbsOp  "parAtAbs#"  GenPrimOp
2300    a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
2301    with
2302    has_side_effects = True
2303
2304 primop  ParAtRelOp  "parAtRel#" GenPrimOp
2305    a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
2306    with
2307    has_side_effects = True
2308
2309 primop  ParAtForNowOp  "parAtForNow#" GenPrimOp
2310    b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
2311    with
2312    has_side_effects = True
2313
2314 -- copyable# and noFollow# are yet to be implemented (for GpH)
2315 --
2316 --primop  CopyableOp  "copyable#" GenPrimOp
2317 --   a -> Int#
2318 --   with
2319 --   has_side_effects = True
2320 --
2321 --primop  NoFollowOp "noFollow#" GenPrimOp
2322 --   a -> Int#
2323 --   with
2324 --   has_side_effects = True
2325
2326
2327 ------------------------------------------------------------------------
2328 section "Tag to enum stuff"
2329         {Convert back and forth between values of enumerated types
2330         and small integers.}
2331 ------------------------------------------------------------------------
2332
2333 primop  DataToTagOp "dataToTag#" GenPrimOp
2334    a -> Int#
2335    with
2336    strictness  = { \ _arity -> mkClosedStrictSig [evalDmd] topRes }
2337
2338         -- dataToTag# must have an evaluated argument
2339
2340 primop  TagToEnumOp "tagToEnum#" GenPrimOp
2341    Int# -> a
2342
2343 ------------------------------------------------------------------------
2344 section "Bytecode operations"
2345         {Support for the bytecode interpreter and linker.}
2346 ------------------------------------------------------------------------
2347
2348 primtype BCO#
2349    {Primitive bytecode type.}
2350
2351 primop   AddrToAnyOp "addrToAny#" GenPrimOp
2352    Addr# -> (# a #)
2353    {Convert an {\tt Addr\#} to a followable Any type.}
2354    with
2355    code_size = 0
2356
2357 primop   MkApUpd0_Op "mkApUpd0#" GenPrimOp
2358    BCO# -> (# a #)
2359    with
2360    out_of_line = True
2361
2362 primop  NewBCOOp "newBCO#" GenPrimOp
2363    ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s, BCO# #)
2364    with
2365    has_side_effects = True
2366    out_of_line      = True
2367
2368 primop  UnpackClosureOp "unpackClosure#" GenPrimOp
2369    a -> (# Addr#, Array# b, ByteArray# #)
2370    with
2371    out_of_line = True
2372
2373 primop  GetApStackValOp "getApStackVal#" GenPrimOp
2374    a -> Int# -> (# Int#, b #)
2375    with
2376    out_of_line = True
2377
2378 ------------------------------------------------------------------------
2379 section "Misc"
2380         {These aren't nearly as wired in as Etc...}
2381 ------------------------------------------------------------------------
2382
2383 primop  GetCCSOfOp "getCCSOf#" GenPrimOp
2384    a -> State# s -> (# State# s, Addr# #)
2385
2386 primop  GetCurrentCCSOp "getCurrentCCS#" GenPrimOp
2387    a -> State# s -> (# State# s, Addr# #)
2388    { Returns the current {\tt CostCentreStack} (value is {\tt NULL} if
2389      not profiling).  Takes a dummy argument which can be used to
2390      avoid the call to {\tt getCCCS\#} being floated out by the
2391      simplifier, which would result in an uninformative stack
2392      ("CAF"). }
2393
2394 ------------------------------------------------------------------------
2395 section "Etc"
2396         {Miscellaneous built-ins}
2397 ------------------------------------------------------------------------
2398
2399 primtype Proxy# a
2400    { The type constructor {\tt Proxy#} is used to bear witness to some
2401    type variable. It's used when you want to pass around proxy values
2402    for doing things like modelling type applications. A {\tt Proxy#}
2403    is not only unboxed, it also has a polymorphic kind, and has no
2404    runtime representation, being totally free. }
2405
2406 pseudoop "proxy#"
2407    Proxy# a
2408    { Witness for an unboxed {\tt Proxy#} value, which has no runtime
2409    representation. }
2410
2411 pseudoop   "seq"
2412    a -> b -> b
2413    { Evaluates its first argument to head normal form, and then returns its second
2414         argument as the result. }
2415
2416 primtype Any k
2417         { The type constructor {\tt Any} is type to which you can unsafely coerce any
2418         lifted type, and back.
2419
2420           * It is lifted, and hence represented by a pointer
2421
2422           * It does not claim to be a {\it data} type, and that's important for
2423             the code generator, because the code gen may {\it enter} a data value
2424             but never enters a function value.
2425
2426         It's also used to instantiate un-constrained type variables after type
2427         checking.  For example, {\tt length} has type
2428
2429         {\tt length :: forall a. [a] -> Int}
2430
2431         and the list datacon for the empty list has type
2432
2433         {\tt [] :: forall a. [a]}
2434
2435         In order to compose these two terms as {\tt length []} a type
2436         application is required, but there is no constraint on the
2437         choice.  In this situation GHC uses {\tt Any}:
2438
2439         {\tt length (Any *) ([] (Any *))}
2440
2441         Note that {\tt Any} is kind polymorphic, and takes a kind {\tt k} as its
2442         first argument. The kind of {\tt Any} is thus {\tt forall k. k -> k}.}
2443
2444 primtype AnyK
2445         { The kind {\tt AnyK} is the kind level counterpart to {\tt Any}. In a
2446         kind polymorphic setting, a similar example to the length of the empty
2447         list can be given at the type level:
2448
2449         {\tt type family Length (l :: [k]) :: Nat}
2450         {\tt type instance Length [] = Zero}
2451
2452         When {\tt Length} is applied to the empty (promoted) list it will have
2453         the kind {\tt Length AnyK []}.
2454
2455         {\tt AnyK} is currently not exported and cannot be used directly, but
2456         you might see it in debug output from the compiler.
2457         }
2458
2459 pseudoop   "unsafeCoerce#"
2460    a -> b
2461    { The function {\tt unsafeCoerce\#} allows you to side-step the typechecker entirely. That
2462         is, it allows you to coerce any type into any other type. If you use this function,
2463         you had better get it right, otherwise segmentation faults await. It is generally
2464         used when you want to write a program that you know is well-typed, but where Haskell's
2465         type system is not expressive enough to prove that it is well typed.
2466
2467         The following uses of {\tt unsafeCoerce\#} are supposed to work (i.e. not lead to
2468         spurious compile-time or run-time crashes):
2469
2470          * Casting any lifted type to {\tt Any}
2471
2472          * Casting {\tt Any} back to the real type
2473
2474          * Casting an unboxed type to another unboxed type of the same size
2475            (but not coercions between floating-point and integral types)
2476
2477          * Casting between two types that have the same runtime representation.  One case is when
2478            the two types differ only in "phantom" type parameters, for example
2479            {\tt Ptr Int} to {\tt Ptr Float}, or {\tt [Int]} to {\tt [Float]} when the list is
2480            known to be empty.  Also, a {\tt newtype} of a type {\tt T} has the same representation
2481            at runtime as {\tt T}.
2482
2483         Other uses of {\tt unsafeCoerce\#} are undefined.  In particular, you should not use
2484         {\tt unsafeCoerce\#} to cast a T to an algebraic data type D, unless T is also
2485         an algebraic data type.  For example, do not cast {\tt Int->Int} to {\tt Bool}, even if
2486         you later cast that {\tt Bool} back to {\tt Int->Int} before applying it.  The reasons
2487         have to do with GHC's internal representation details (for the congnoscenti, data values
2488         can be entered but function closures cannot).  If you want a safe type to cast things
2489         to, use {\tt Any}, which is not an algebraic data type.
2490
2491         }
2492
2493 -- NB. It is tempting to think that casting a value to a type that it doesn't have is safe
2494 -- as long as you don't "do anything" with the value in its cast form, such as seq on it.  This
2495 -- isn't the case: the compiler can insert seqs itself, and if these happen at the wrong type,
2496 -- Bad Things Might Happen.  See bug #1616: in this case we cast a function of type (a,b) -> (a,b)
2497 -- to () -> () and back again.  The strictness analyser saw that the function was strict, but
2498 -- the wrapper had type () -> (), and hence the wrapper de-constructed the (), the worker re-constructed
2499 -- a new (), with the result that the code ended up with "case () of (a,b) -> ...".
2500
2501 primop  TraceEventOp "traceEvent#" GenPrimOp
2502    Addr# -> State# s -> State# s
2503    { Emits an event via the RTS tracing framework.  The contents
2504      of the event is the zero-terminated byte string passed as the first
2505      argument.  The event will be emitted either to the .eventlog file,
2506      or to stderr, depending on the runtime RTS flags. }
2507    with
2508    has_side_effects = True
2509    out_of_line      = True
2510
2511 primop  TraceMarkerOp "traceMarker#" GenPrimOp
2512    Addr# -> State# s -> State# s
2513    { Emits a marker event via the RTS tracing framework.  The contents
2514      of the event is the zero-terminated byte string passed as the first
2515      argument.  The event will be emitted either to the .eventlog file,
2516      or to stderr, depending on the runtime RTS flags. }
2517    with
2518    has_side_effects = True
2519    out_of_line      = True
2520
2521 ------------------------------------------------------------------------
2522 section "Safe coercions"
2523 ------------------------------------------------------------------------
2524
2525 pseudoop   "coerce"
2526    Coercible a b => a -> b
2527    { The function {\tt coerce} allows you to safely convert between values of
2528      types that have the same representation with no run-time overhead. In the
2529      simplest case you can use it instead of a newtype constructor, to go from
2530      the newtype's concrete type to the abstract type. But it also works in
2531      more complicated settings, e.g. converting a list of newtypes to a list of
2532      concrete types.
2533    }
2534
2535 ------------------------------------------------------------------------
2536 section "SIMD Vectors"
2537         {Operations on SIMD vectors.}
2538 ------------------------------------------------------------------------
2539
2540 #define ALL_VECTOR_TYPES \
2541   [<Int8,Int#,16>,<Int16,Int#,8>,<Int32,INT32,4>,<Int64,INT64,2> \
2542   ,<Int8,Int#,32>,<Int16,Int#,16>,<Int32,INT32,8>,<Int64,INT64,4> \
2543   ,<Int8,Int#,64>,<Int16,Int#,32>,<Int32,INT32,16>,<Int64,INT64,8> \
2544   ,<Word8,Word#,16>,<Word16,Word#,8>,<Word32,WORD32,4>,<Word64,WORD64,2> \
2545   ,<Word8,Word#,32>,<Word16,Word#,16>,<Word32,WORD32,8>,<Word64,WORD64,4> \
2546   ,<Word8,Word#,64>,<Word16,Word#,32>,<Word32,WORD32,16>,<Word64,WORD64,8> \
2547   ,<Float,Float#,4>,<Double,Double#,2> \
2548   ,<Float,Float#,8>,<Double,Double#,4> \
2549   ,<Float,Float#,16>,<Double,Double#,8>]
2550
2551 #define SIGNED_VECTOR_TYPES \
2552   [<Int8,Int#,16>,<Int16,Int#,8>,<Int32,INT32,4>,<Int64,INT64,2> \
2553   ,<Int8,Int#,32>,<Int16,Int#,16>,<Int32,INT32,8>,<Int64,INT64,4> \
2554   ,<Int8,Int#,64>,<Int16,Int#,32>,<Int32,INT32,16>,<Int64,INT64,8> \
2555   ,<Float,Float#,4>,<Double,Double#,2> \
2556   ,<Float,Float#,8>,<Double,Double#,4> \
2557   ,<Float,Float#,16>,<Double,Double#,8>]
2558
2559 #define FLOAT_VECTOR_TYPES \
2560   [<Float,Float#,4>,<Double,Double#,2> \
2561   ,<Float,Float#,8>,<Double,Double#,4> \
2562   ,<Float,Float#,16>,<Double,Double#,8>]
2563
2564 #define INT_VECTOR_TYPES \
2565   [<Int8,Int#,16>,<Int16,Int#,8>,<Int32,INT32,4>,<Int64,INT64,2> \
2566   ,<Int8,Int#,32>,<Int16,Int#,16>,<Int32,INT32,8>,<Int64,INT64,4> \
2567   ,<Int8,Int#,64>,<Int16,Int#,32>,<Int32,INT32,16>,<Int64,INT64,8> \
2568   ,<Word8,Word#,16>,<Word16,Word#,8>,<Word32,WORD32,4>,<Word64,WORD64,2> \
2569   ,<Word8,Word#,32>,<Word16,Word#,16>,<Word32,WORD32,8>,<Word64,WORD64,4> \
2570   ,<Word8,Word#,64>,<Word16,Word#,32>,<Word32,WORD32,16>,<Word64,WORD64,8>]
2571
2572 primtype VECTOR
2573    with llvm_only = True
2574         vector = ALL_VECTOR_TYPES
2575
2576 primop VecBroadcastOp "broadcast#" GenPrimOp
2577    SCALAR -> VECTOR
2578    { Broadcast a scalar to all elements of a vector. }
2579    with llvm_only = True
2580         vector = ALL_VECTOR_TYPES
2581
2582 primop VecPackOp "pack#" GenPrimOp
2583    VECTUPLE -> VECTOR
2584    { Pack the elements of an unboxed tuple into a vector. }
2585    with llvm_only = True
2586         vector = ALL_VECTOR_TYPES
2587
2588 primop VecUnpackOp "unpack#" GenPrimOp
2589    VECTOR -> VECTUPLE
2590    { Unpack the elements of a vector into an unboxed tuple. #}
2591    with llvm_only = True
2592         vector = ALL_VECTOR_TYPES
2593
2594 primop VecInsertOp "insert#" GenPrimOp
2595    VECTOR -> SCALAR -> Int# -> VECTOR
2596    { Insert a scalar at the given position in a vector. }
2597    with can_fail = True
2598         llvm_only = True
2599         vector = ALL_VECTOR_TYPES
2600
2601 primop VecAddOp "plus#" Dyadic
2602    VECTOR -> VECTOR -> VECTOR
2603    { Add two vectors element-wise. }
2604    with commutable = True
2605         llvm_only = True
2606         vector = ALL_VECTOR_TYPES
2607
2608 primop VecSubOp "minus#" Dyadic
2609    VECTOR -> VECTOR -> VECTOR
2610    { Subtract two vectors element-wise. }
2611    with llvm_only = True
2612         vector = ALL_VECTOR_TYPES
2613
2614 primop VecMulOp "times#" Dyadic
2615    VECTOR -> VECTOR -> VECTOR
2616    { Multiply two vectors element-wise. }
2617    with commutable = True
2618         llvm_only = True
2619         vector = ALL_VECTOR_TYPES
2620
2621 primop VecDivOp "divide#" Dyadic
2622    VECTOR -> VECTOR -> VECTOR
2623    { Divide two vectors element-wise. }
2624    with can_fail = True
2625         llvm_only = True
2626         vector = FLOAT_VECTOR_TYPES
2627
2628 primop VecQuotOp "quot#" Dyadic
2629    VECTOR -> VECTOR -> VECTOR
2630    { Rounds towards zero element-wise. }
2631    with can_fail = True
2632         llvm_only = True
2633         vector = INT_VECTOR_TYPES
2634
2635 primop VecRemOp "rem#" Dyadic
2636    VECTOR -> VECTOR -> VECTOR
2637    { Satisfies \texttt{(quot\# x y) times\# y plus\# (rem\# x y) == x}. }
2638    with can_fail = True
2639         llvm_only = True
2640         vector = INT_VECTOR_TYPES
2641
2642 primop VecNegOp "negate#" Monadic
2643    VECTOR -> VECTOR
2644    { Negate element-wise. }
2645    with llvm_only = True
2646         vector = SIGNED_VECTOR_TYPES
2647
2648 primop VecIndexByteArrayOp "indexArray#" GenPrimOp
2649    ByteArray# -> Int# -> VECTOR
2650    { Read a vector from specified index of immutable array. }
2651    with can_fail = True
2652         llvm_only = True
2653         vector = ALL_VECTOR_TYPES
2654
2655 primop VecReadByteArrayOp "readArray#" GenPrimOp
2656    MutableByteArray# s -> Int# -> State# s -> (# State# s, VECTOR #)
2657    { Read a vector from specified index of mutable array. }
2658    with has_side_effects = True
2659         can_fail = True
2660         llvm_only = True
2661         vector = ALL_VECTOR_TYPES
2662
2663 primop VecWriteByteArrayOp "writeArray#" GenPrimOp
2664    MutableByteArray# s -> Int# -> VECTOR -> State# s -> State# s
2665    { Write a vector to specified index of mutable array. }
2666    with has_side_effects = True
2667         can_fail = True
2668         llvm_only = True
2669         vector = ALL_VECTOR_TYPES
2670
2671 primop VecIndexOffAddrOp "indexOffAddr#" GenPrimOp
2672    Addr# -> Int# -> VECTOR
2673    { Reads vector; offset in bytes. }
2674    with can_fail = True
2675         llvm_only = True
2676         vector = ALL_VECTOR_TYPES
2677
2678 primop VecReadOffAddrOp "readOffAddr#" GenPrimOp
2679    Addr# -> Int# -> State# s -> (# State# s, VECTOR #)
2680    { Reads vector; offset in bytes. }
2681    with has_side_effects = True
2682         can_fail = True
2683         llvm_only = True
2684         vector = ALL_VECTOR_TYPES
2685
2686 primop VecWriteOffAddrOp "writeOffAddr#" GenPrimOp
2687    Addr# -> Int# -> VECTOR -> State# s -> State# s
2688    { Write vector; offset in bytes. }
2689    with has_side_effects = True
2690         can_fail = True
2691         llvm_only = True
2692         vector = ALL_VECTOR_TYPES
2693
2694
2695 primop VecIndexScalarByteArrayOp "indexArrayAs#" GenPrimOp
2696    ByteArray# -> Int# -> VECTOR
2697    { Read a vector from specified index of immutable array of scalars; offset is in scalar elements. }
2698    with can_fail = True
2699         llvm_only = True
2700         vector = ALL_VECTOR_TYPES
2701
2702 primop VecReadScalarByteArrayOp "readArrayAs#" GenPrimOp
2703    MutableByteArray# s -> Int# -> State# s -> (# State# s, VECTOR #)
2704    { Read a vector from specified index of mutable array of scalars; offset is in scalar elements. }
2705    with has_side_effects = True
2706         can_fail = True
2707         llvm_only = True
2708         vector = ALL_VECTOR_TYPES
2709
2710 primop VecWriteScalarByteArrayOp "writeArrayAs#" GenPrimOp
2711    MutableByteArray# s -> Int# -> VECTOR -> State# s -> State# s
2712    { Write a vector to specified index of mutable array of scalars; offset is in scalar elements. }
2713    with has_side_effects = True
2714         can_fail = True
2715         llvm_only = True
2716         vector = ALL_VECTOR_TYPES
2717
2718 primop VecIndexScalarOffAddrOp "indexOffAddrAs#" GenPrimOp
2719    Addr# -> Int# -> VECTOR
2720    { Reads vector; offset in scalar elements. }
2721    with can_fail = True
2722         llvm_only = True
2723         vector = ALL_VECTOR_TYPES
2724
2725 primop VecReadScalarOffAddrOp "readOffAddrAs#" GenPrimOp
2726    Addr# -> Int# -> State# s -> (# State# s, VECTOR #)
2727    { Reads vector; offset in scalar elements. }
2728    with has_side_effects = True
2729         can_fail = True
2730         llvm_only = True
2731         vector = ALL_VECTOR_TYPES
2732
2733 primop VecWriteScalarOffAddrOp "writeOffAddrAs#" GenPrimOp
2734    Addr# -> Int# -> VECTOR -> State# s -> State# s
2735    { Write vector; offset in scalar elements. }
2736    with has_side_effects = True
2737         can_fail = True
2738         llvm_only = True
2739         vector = ALL_VECTOR_TYPES
2740
2741 ------------------------------------------------------------------------
2742
2743 section "Prefetch"
2744         {Prefetch operations: Note how every prefetch operation has a name
2745   with the pattern prefetch*N#, where N is either 0,1,2, or 3.
2746
2747   This suffix number, N, is the "locality level" of the prefetch, following the
2748   convention in GCC and other compilers.
2749   Higher locality numbers correspond to the memory being loaded in more
2750   levels of the cpu cache, and being retained after initial use. The naming
2751   convention follows the naming convention of the prefetch intrinsic found
2752   in the GCC and Clang C compilers.
2753
2754   On the LLVM backend, prefetch*N# uses the LLVM prefetch intrinsic
2755   with locality level N. The code generated by LLVM is target architecture
2756   dependent, but should agree with the GHC NCG on x86 systems.
2757
2758   On the Sparc and PPC native backends, prefetch*N is a No-Op.
2759
2760   On the x86 NCG, N=0 will generate prefetchNTA,
2761   N=1 generates prefetcht2, N=2 generates prefetcht1, and
2762   N=3 generates prefetcht0.
2763
2764   For streaming workloads, the prefetch*0 operations are recommended.
2765   For workloads which do many reads or writes to a memory location in a short period of time,
2766   prefetch*3 operations are recommended.
2767
2768   For further reading about prefetch and associated systems performance optimization,
2769   the instruction set and optimization manuals by Intel and other CPU vendors are
2770   excellent starting place.
2771
2772
2773   The "Intel 64 and IA-32 Architectures Optimization Reference Manual" is
2774   especially a helpful read, even if your software is meant for other CPU
2775   architectures or vendor hardware. The manual can be found at
2776   http://www.intel.com/content/www/us/en/architecture-and-technology/64-ia-32-architectures-optimization-manual.html .
2777
2778   The {\tt prefetchMutableByteArray} family of operations has the order of operations
2779   determined by passing around the {\tt State#} token.
2780
2781   For the {\tt prefetchByteArray}
2782   and {\tt prefetchAddr} families of operations, consider the following example:
2783
2784   {\tt let a1 = prefetchByteArray2# a n in ...a1... }
2785
2786   In the above fragement, {\tt a} is the input variable for the prefetch
2787   and {\tt a1 == a} will be true. To ensure that the prefetch is not treated as deadcode,
2788   the body of the let should only use {\tt a1} and NOT {\tt a}. The same principle
2789   applies for uses of prefetch in a loop.
2790
2791   }
2792
2793
2794 ------------------------------------------------------------------------
2795
2796
2797 --- the Int# argument for prefetch is the byte offset on the byteArray or  Addr#
2798
2799 ---
2800 primop PrefetchByteArrayOp3 "prefetchByteArray3#" GenPrimOp
2801    ByteArray# -> Int# -> ByteArray#
2802
2803 primop PrefetchMutableByteArrayOp3 "prefetchMutableByteArray3#" GenPrimOp
2804    MutableByteArray# s -> Int# -> State# s -> State# s
2805
2806 primop PrefetchAddrOp3 "prefetchAddr3#" GenPrimOp
2807     Addr# -> Int# -> Addr#
2808
2809 ----
2810
2811 primop PrefetchByteArrayOp2 "prefetchByteArray2#" GenPrimOp
2812    ByteArray# -> Int# -> ByteArray#
2813
2814 primop PrefetchMutableByteArrayOp2 "prefetchMutableByteArray2#" GenPrimOp
2815    MutableByteArray# s -> Int# -> State# s -> State# s
2816
2817 primop PrefetchAddrOp2 "prefetchAddr2#" GenPrimOp
2818    Addr# -> Int# -> Addr#
2819
2820 ----
2821
2822 primop PrefetchByteArrayOp1 "prefetchByteArray1#" GenPrimOp
2823    ByteArray# -> Int# -> ByteArray#
2824
2825 primop PrefetchMutableByteArrayOp1 "prefetchMutableByteArray1#" GenPrimOp
2826    MutableByteArray# s -> Int# -> State# s -> State# s
2827
2828 primop PrefetchAddrOp1 "prefetchAddr1#" GenPrimOp
2829    Addr# -> Int# -> Addr#
2830
2831 ----
2832
2833 primop PrefetchByteArrayOp0 "prefetchByteArray0#" GenPrimOp
2834    ByteArray# -> Int# -> ByteArray#
2835
2836 primop PrefetchMutableByteArrayOp0 "prefetchMutableByteArray0#" GenPrimOp
2837    MutableByteArray# s -> Int# -> State# s -> State# s
2838
2839 primop PrefetchAddrOp0 "prefetchAddr0#" GenPrimOp
2840    Addr# -> Int# -> Addr#
2841
2842
2843
2844 ------------------------------------------------------------------------
2845 ---                                                                  ---
2846 ------------------------------------------------------------------------
2847
2848 thats_all_folks