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