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