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