Implement atomicReadMVar, fixing #4001.
[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  AtomicReadMVarOp "atomicReadMVar#" GenPrimOp
1721    MVar# s a -> State# s -> (# State# s, a #)
1722    {If {\tt MVar\#} is empty, block until it becomes full.
1723    Then read its contents without modifying the MVar, without possibility
1724    of intervention from other threads.}
1725    with
1726    out_of_line      = True
1727    has_side_effects = True
1728
1729 primop  SameMVarOp "sameMVar#" GenPrimOp
1730    MVar# s a -> MVar# s a -> Bool
1731
1732 primop  IsEmptyMVarOp "isEmptyMVar#" GenPrimOp
1733    MVar# s a -> State# s -> (# State# s, Int# #)
1734    {Return 1 if {\tt MVar\#} is empty; 0 otherwise.}
1735    with
1736    out_of_line = True
1737    has_side_effects = True
1738
1739 ------------------------------------------------------------------------
1740 section "Delay/wait operations"
1741 ------------------------------------------------------------------------
1742
1743 primop  DelayOp "delay#" GenPrimOp
1744    Int# -> State# s -> State# s
1745    {Sleep specified number of microseconds.}
1746    with
1747    has_side_effects = True
1748    out_of_line      = True
1749
1750 primop  WaitReadOp "waitRead#" GenPrimOp
1751    Int# -> State# s -> State# s
1752    {Block until input is available on specified file descriptor.}
1753    with
1754    has_side_effects = True
1755    out_of_line      = True
1756
1757 primop  WaitWriteOp "waitWrite#" GenPrimOp
1758    Int# -> State# s -> State# s
1759    {Block until output is possible on specified file descriptor.}
1760    with
1761    has_side_effects = True
1762    out_of_line      = True
1763
1764 #ifdef mingw32_TARGET_OS
1765 primop  AsyncReadOp "asyncRead#" GenPrimOp
1766    Int# -> Int# -> Int# -> Addr# -> State# RealWorld-> (# State# RealWorld, Int#, Int# #)
1767    {Asynchronously read bytes from specified file descriptor.}
1768    with
1769    has_side_effects = True
1770    out_of_line      = True
1771
1772 primop  AsyncWriteOp "asyncWrite#" GenPrimOp
1773    Int# -> Int# -> Int# -> Addr# -> State# RealWorld-> (# State# RealWorld, Int#, Int# #)
1774    {Asynchronously write bytes from specified file descriptor.}
1775    with
1776    has_side_effects = True
1777    out_of_line      = True
1778
1779 primop  AsyncDoProcOp "asyncDoProc#" GenPrimOp
1780    Addr# -> Addr# -> State# RealWorld-> (# State# RealWorld, Int#, Int# #)
1781    {Asynchronously perform procedure (first arg), passing it 2nd arg.}
1782    with
1783    has_side_effects = True
1784    out_of_line      = True
1785
1786 #endif
1787
1788 ------------------------------------------------------------------------
1789 section "Concurrency primitives"
1790 ------------------------------------------------------------------------
1791
1792 primtype State# s
1793         { {\tt State\#} is the primitive, unlifted type of states.  It has
1794         one type parameter, thus {\tt State\# RealWorld}, or {\tt State\# s},
1795         where s is a type variable. The only purpose of the type parameter
1796         is to keep different state threads separate.  It is represented by
1797         nothing at all. }
1798
1799 primtype RealWorld
1800         { {\tt RealWorld} is deeply magical.  It is {\it primitive}, but it is not
1801         {\it unlifted} (hence {\tt ptrArg}).  We never manipulate values of type
1802         {\tt RealWorld}; it's only used in the type system, to parameterise {\tt State\#}. }
1803
1804 primtype ThreadId#
1805         {(In a non-concurrent implementation, this can be a singleton
1806         type, whose (unique) value is returned by {\tt myThreadId\#}.  The 
1807         other operations can be omitted.)}
1808
1809 primop  ForkOp "fork#" GenPrimOp
1810    a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
1811    with
1812    has_side_effects = True
1813    out_of_line      = True
1814
1815 primop  ForkOnOp "forkOn#" GenPrimOp
1816    Int# -> a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
1817    with
1818    has_side_effects = True
1819    out_of_line      = True
1820
1821 primop  KillThreadOp "killThread#"  GenPrimOp
1822    ThreadId# -> a -> State# RealWorld -> State# RealWorld
1823    with
1824    has_side_effects = True
1825    out_of_line      = True
1826
1827 primop  YieldOp "yield#" GenPrimOp
1828    State# RealWorld -> State# RealWorld
1829    with
1830    has_side_effects = True
1831    out_of_line      = True
1832
1833 primop  MyThreadIdOp "myThreadId#" GenPrimOp
1834    State# RealWorld -> (# State# RealWorld, ThreadId# #)
1835    with
1836    out_of_line = True
1837    has_side_effects = True
1838
1839 primop LabelThreadOp "labelThread#" GenPrimOp
1840    ThreadId# -> Addr# -> State# RealWorld -> State# RealWorld
1841    with
1842    has_side_effects = True
1843    out_of_line      = True
1844    
1845 primop  IsCurrentThreadBoundOp "isCurrentThreadBound#" GenPrimOp
1846    State# RealWorld -> (# State# RealWorld, Int# #)
1847    with
1848    out_of_line = True
1849    has_side_effects = True
1850
1851 primop  NoDuplicateOp "noDuplicate#" GenPrimOp
1852    State# RealWorld -> State# RealWorld
1853    with
1854    out_of_line = True
1855    has_side_effects = True
1856
1857 primop  ThreadStatusOp "threadStatus#" GenPrimOp
1858    ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, Int#, Int# #)
1859    with
1860    out_of_line = True
1861    has_side_effects = True
1862
1863 ------------------------------------------------------------------------
1864 section "Weak pointers"
1865 ------------------------------------------------------------------------
1866
1867 primtype Weak# b
1868
1869 -- note that tyvar "o" denotes openAlphaTyVar
1870
1871 primop  MkWeakOp "mkWeak#" GenPrimOp
1872    o -> b -> c -> State# RealWorld -> (# State# RealWorld, Weak# b #)
1873    with
1874    has_side_effects = True
1875    out_of_line      = True
1876
1877 primop  MkWeakNoFinalizerOp "mkWeakNoFinalizer#" GenPrimOp
1878    o -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)
1879    with
1880    has_side_effects = True
1881    out_of_line      = True
1882
1883 primop  AddCFinalizerToWeakOp "addCFinalizerToWeak#" GenPrimOp
1884    Addr# -> Addr# -> Int# -> Addr# -> Weak# b
1885           -> State# RealWorld -> (# State# RealWorld, Int# #)
1886    { {\tt addCFinalizerToWeak# fptr ptr flag eptr w} attaches a C
1887      function pointer {\tt fptr} to a weak pointer {\tt w} as a finalizer. If
1888      {\tt flag} is zero, {\tt fptr} will be called with one argument,
1889      {\tt ptr}. Otherwise, it will be called with two arguments,
1890      {\tt eptr} and {\tt ptr}. {\tt addCFinalizerToWeak#} returns
1891      1 on success, or 0 if {\tt w} is already dead. }
1892    with
1893    has_side_effects = True
1894    out_of_line      = True
1895
1896 primop  DeRefWeakOp "deRefWeak#" GenPrimOp
1897    Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)
1898    with
1899    has_side_effects = True
1900    out_of_line      = True
1901
1902 primop  FinalizeWeakOp "finalizeWeak#" GenPrimOp
1903    Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, 
1904               (State# RealWorld -> (# State# RealWorld, () #)) #)
1905    with
1906    has_side_effects = True
1907    out_of_line      = True
1908
1909 primop TouchOp "touch#" GenPrimOp
1910    o -> State# RealWorld -> State# RealWorld
1911    with
1912    code_size = { 0 }
1913    has_side_effects = True
1914
1915 ------------------------------------------------------------------------
1916 section "Stable pointers and names"
1917 ------------------------------------------------------------------------
1918
1919 primtype StablePtr# a
1920
1921 primtype StableName# a
1922
1923 primop  MakeStablePtrOp "makeStablePtr#" GenPrimOp
1924    a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
1925    with
1926    has_side_effects = True
1927    out_of_line      = True
1928
1929 primop  DeRefStablePtrOp "deRefStablePtr#" GenPrimOp
1930    StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
1931    with
1932    has_side_effects = True
1933    out_of_line      = True
1934
1935 primop  EqStablePtrOp "eqStablePtr#" GenPrimOp
1936    StablePtr# a -> StablePtr# a -> Int#
1937    with
1938    has_side_effects = True
1939
1940 primop  MakeStableNameOp "makeStableName#" GenPrimOp
1941    a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
1942    with
1943    has_side_effects = True
1944    out_of_line      = True
1945
1946 primop  EqStableNameOp "eqStableName#" GenPrimOp
1947    StableName# a -> StableName# b -> Int#
1948
1949 primop  StableNameToIntOp "stableNameToInt#" GenPrimOp
1950    StableName# a -> Int#
1951
1952 ------------------------------------------------------------------------
1953 section "Unsafe pointer equality"
1954 --  (#1 Bad Guy: Alistair Reid :)   
1955 ------------------------------------------------------------------------
1956
1957 primop  ReallyUnsafePtrEqualityOp "reallyUnsafePtrEquality#" GenPrimOp
1958    a -> a -> Int#
1959
1960 ------------------------------------------------------------------------
1961 section "Parallelism"
1962 ------------------------------------------------------------------------
1963
1964 primop  ParOp "par#" GenPrimOp
1965    a -> Int#
1966    with
1967       -- Note that Par is lazy to avoid that the sparked thing
1968       -- gets evaluted strictly, which it should *not* be
1969    has_side_effects = True
1970    code_size = { primOpCodeSizeForeignCall }
1971
1972 primop SparkOp "spark#" GenPrimOp
1973    a -> State# s -> (# State# s, a #)
1974    with has_side_effects = True
1975    code_size = { primOpCodeSizeForeignCall }
1976
1977 primop SeqOp "seq#" GenPrimOp
1978    a -> State# s -> (# State# s, a #)
1979
1980    -- why return the value?  So that we can control sharing of seq'd
1981    -- values: in
1982    --    let x = e in x `seq` ... x ...
1983    -- we don't want to inline x, so better to represent it as
1984    --    let x = e in case seq# x RW of (# _, x' #) -> ... x' ...
1985    -- also it matches the type of rseq in the Eval monad.
1986
1987 primop GetSparkOp "getSpark#" GenPrimOp
1988    State# s -> (# State# s, Int#, a #)
1989    with
1990    has_side_effects = True
1991    out_of_line = True
1992
1993 primop NumSparks "numSparks#" GenPrimOp
1994    State# s -> (# State# s, Int# #)
1995    { Returns the number of sparks in the local spark pool. }
1996    with
1997    has_side_effects = True
1998    out_of_line = True
1999
2000 -- HWL: The first 4 Int# in all par... annotations denote:
2001 --   name, granularity info, size of result, degree of parallelism
2002 --      Same  structure as _seq_ i.e. returns Int#
2003 -- KSW: v, the second arg in parAt# and parAtForNow#, is used only to determine
2004 --   `the processor containing the expression v'; it is not evaluated
2005
2006 primop  ParGlobalOp  "parGlobal#"  GenPrimOp
2007    a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
2008    with
2009    has_side_effects = True
2010
2011 primop  ParLocalOp  "parLocal#"  GenPrimOp
2012    a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
2013    with
2014    has_side_effects = True
2015
2016 primop  ParAtOp  "parAt#"  GenPrimOp
2017    b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
2018    with
2019    has_side_effects = True
2020
2021 primop  ParAtAbsOp  "parAtAbs#"  GenPrimOp
2022    a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
2023    with
2024    has_side_effects = True
2025
2026 primop  ParAtRelOp  "parAtRel#" GenPrimOp
2027    a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
2028    with
2029    has_side_effects = True
2030
2031 primop  ParAtForNowOp  "parAtForNow#" GenPrimOp
2032    b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
2033    with
2034    has_side_effects = True
2035
2036 -- copyable# and noFollow# are yet to be implemented (for GpH)
2037 --
2038 --primop  CopyableOp  "copyable#" GenPrimOp
2039 --   a -> Int#
2040 --   with
2041 --   has_side_effects = True
2042 --
2043 --primop  NoFollowOp "noFollow#" GenPrimOp
2044 --   a -> Int#
2045 --   with
2046 --   has_side_effects = True
2047
2048
2049 ------------------------------------------------------------------------
2050 section "Tag to enum stuff"
2051         {Convert back and forth between values of enumerated types
2052         and small integers.}
2053 ------------------------------------------------------------------------
2054
2055 primop  DataToTagOp "dataToTag#" GenPrimOp
2056    a -> Int#
2057    with
2058    strictness  = { \ _arity -> mkStrictSig (mkTopDmdType [evalDmd] topRes) }
2059
2060         -- dataToTag# must have an evaluated argument
2061
2062 primop  TagToEnumOp "tagToEnum#" GenPrimOp     
2063    Int# -> a
2064
2065 ------------------------------------------------------------------------
2066 section "Bytecode operations" 
2067         {Support for the bytecode interpreter and linker.}
2068 ------------------------------------------------------------------------
2069
2070 primtype BCO#
2071    {Primitive bytecode type.}
2072
2073 primop   AddrToAnyOp "addrToAny#" GenPrimOp
2074    Addr# -> (# a #)
2075    {Convert an {\tt Addr\#} to a followable Any type.}
2076    with
2077    code_size = 0
2078
2079 primop   MkApUpd0_Op "mkApUpd0#" GenPrimOp
2080    BCO# -> (# a #)
2081    with
2082    out_of_line = True
2083
2084 primop  NewBCOOp "newBCO#" GenPrimOp
2085    ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s, BCO# #)
2086    with
2087    has_side_effects = True
2088    out_of_line      = True
2089
2090 primop  UnpackClosureOp "unpackClosure#" GenPrimOp
2091    a -> (# Addr#, Array# b, ByteArray# #)
2092    with
2093    out_of_line = True
2094
2095 primop  GetApStackValOp "getApStackVal#" GenPrimOp
2096    a -> Int# -> (# Int#, b #)
2097    with
2098    out_of_line = True
2099
2100 ------------------------------------------------------------------------
2101 section "Misc"
2102         {These aren't nearly as wired in as Etc...}
2103 ------------------------------------------------------------------------
2104
2105 primop  GetCCSOfOp "getCCSOf#" GenPrimOp
2106    a -> State# s -> (# State# s, Addr# #)
2107
2108 primop  GetCurrentCCSOp "getCurrentCCS#" GenPrimOp
2109    a -> State# s -> (# State# s, Addr# #)
2110    { Returns the current {\tt CostCentreStack} (value is {\tt NULL} if
2111      not profiling).  Takes a dummy argument which can be used to
2112      avoid the call to {\tt getCCCS\#} being floated out by the
2113      simplifier, which would result in an uninformative stack
2114      ("CAF"). }
2115
2116 ------------------------------------------------------------------------
2117 section "Etc" 
2118         {Miscellaneous built-ins}
2119 ------------------------------------------------------------------------
2120
2121 pseudoop   "seq"
2122    a -> b -> b
2123    { Evaluates its first argument to head normal form, and then returns its second
2124         argument as the result. }
2125
2126 primtype Any k
2127         { The type constructor {\tt Any} is type to which you can unsafely coerce any
2128         lifted type, and back. 
2129
2130           * It is lifted, and hence represented by a pointer
2131
2132           * It does not claim to be a {\it data} type, and that's important for
2133             the code generator, because the code gen may {\it enter} a data value
2134             but never enters a function value.  
2135
2136         It's also used to instantiate un-constrained type variables after type
2137         checking.  For example, {\tt length} has type
2138
2139         {\tt length :: forall a. [a] -> Int}
2140
2141         and the list datacon for the empty list has type
2142
2143         {\tt [] :: forall a. [a]}
2144
2145         In order to compose these two terms as {\tt length []} a type
2146         application is required, but there is no constraint on the
2147         choice.  In this situation GHC uses {\tt Any}:
2148
2149         {\tt length (Any *) ([] (Any *))}
2150
2151         Note that {\tt Any} is kind polymorphic, and takes a kind {\tt k} as its
2152         first argument. The kind of {\tt Any} is thus {\tt forall k. k -> k}.}
2153
2154 primtype AnyK
2155         { The kind {\tt AnyK} is the kind level counterpart to {\tt Any}. In a
2156         kind polymorphic setting, a similar example to the length of the empty
2157         list can be given at the type level:
2158
2159         {\tt type family Length (l :: [k]) :: Nat}
2160         {\tt type instance Length [] = Zero}
2161
2162         When {\tt Length} is applied to the empty (promoted) list it will have
2163         the kind {\tt Length AnyK []}.
2164
2165         {\tt AnyK} is currently not exported and cannot be used directly, but
2166         you might see it in debug output from the compiler.
2167         }
2168
2169 pseudoop   "unsafeCoerce#"
2170    a -> b
2171    { The function {\tt unsafeCoerce\#} allows you to side-step the typechecker entirely. That
2172         is, it allows you to coerce any type into any other type. If you use this function,
2173         you had better get it right, otherwise segmentation faults await. It is generally
2174         used when you want to write a program that you know is well-typed, but where Haskell's
2175         type system is not expressive enough to prove that it is well typed.
2176
2177         The following uses of {\tt unsafeCoerce\#} are supposed to work (i.e. not lead to
2178         spurious compile-time or run-time crashes):
2179
2180          * Casting any lifted type to {\tt Any}
2181
2182          * Casting {\tt Any} back to the real type
2183
2184          * Casting an unboxed type to another unboxed type of the same size
2185            (but not coercions between floating-point and integral types)
2186
2187          * Casting between two types that have the same runtime representation.  One case is when
2188            the two types differ only in "phantom" type parameters, for example
2189            {\tt Ptr Int} to {\tt Ptr Float}, or {\tt [Int]} to {\tt [Float]} when the list is 
2190            known to be empty.  Also, a {\tt newtype} of a type {\tt T} has the same representation
2191            at runtime as {\tt T}.
2192
2193         Other uses of {\tt unsafeCoerce\#} are undefined.  In particular, you should not use
2194         {\tt unsafeCoerce\#} to cast a T to an algebraic data type D, unless T is also
2195         an algebraic data type.  For example, do not cast {\tt Int->Int} to {\tt Bool}, even if
2196         you later cast that {\tt Bool} back to {\tt Int->Int} before applying it.  The reasons
2197         have to do with GHC's internal representation details (for the congnoscenti, data values
2198         can be entered but function closures cannot).  If you want a safe type to cast things
2199         to, use {\tt Any}, which is not an algebraic data type.
2200         
2201         }
2202
2203 -- NB. It is tempting to think that casting a value to a type that it doesn't have is safe
2204 -- as long as you don't "do anything" with the value in its cast form, such as seq on it.  This
2205 -- isn't the case: the compiler can insert seqs itself, and if these happen at the wrong type,
2206 -- Bad Things Might Happen.  See bug #1616: in this case we cast a function of type (a,b) -> (a,b)
2207 -- to () -> () and back again.  The strictness analyser saw that the function was strict, but
2208 -- the wrapper had type () -> (), and hence the wrapper de-constructed the (), the worker re-constructed
2209 -- a new (), with the result that the code ended up with "case () of (a,b) -> ...".
2210
2211 primop  TraceEventOp "traceEvent#" GenPrimOp
2212    Addr# -> State# s -> State# s
2213    { Emits an event via the RTS tracing framework.  The contents
2214      of the event is the zero-terminated byte string passed as the first
2215      argument.  The event will be emitted either to the .eventlog file,
2216      or to stderr, depending on the runtime RTS flags. }
2217    with
2218    has_side_effects = True
2219    out_of_line      = True
2220
2221 primop  TraceMarkerOp "traceMarker#" GenPrimOp
2222    Addr# -> State# s -> State# s
2223    { Emits a marker event via the RTS tracing framework.  The contents
2224      of the event is the zero-terminated byte string passed as the first
2225      argument.  The event will be emitted either to the .eventlog file,
2226      or to stderr, depending on the runtime RTS flags. }
2227    with
2228    has_side_effects = True
2229    out_of_line      = True
2230
2231
2232 ------------------------------------------------------------------------
2233 section "Float SIMD Vectors" 
2234         {Operations on SIMD vectors of 4 single-precision (32-bit)
2235          floating-point numbers.}
2236 ------------------------------------------------------------------------
2237
2238 primtype FloatX4#
2239    with llvm_only = True
2240
2241 primop FloatToFloatX4Op "floatToFloatX4#" GenPrimOp     
2242    Float# -> FloatX4#
2243    with llvm_only = True
2244
2245 primop FloatX4PackOp "packFloatX4#" GenPrimOp         
2246    Float# -> Float# -> Float# -> Float# -> FloatX4#
2247    with llvm_only = True
2248
2249 primop FloatX4UnpackOp "unpackFloatX4#" GenPrimOp         
2250    FloatX4# -> (# Float#, Float#, Float#, Float# #)
2251    with llvm_only = True
2252
2253 primop FloatX4InsertOp "insertFloatX4#" GenPrimOp     
2254    FloatX4# -> Float# -> Int# -> FloatX4#
2255    with can_fail = True
2256         llvm_only = True
2257
2258 primop FloatX4AddOp "plusFloatX4#" Dyadic            
2259    FloatX4# -> FloatX4# -> FloatX4#
2260    with commutable = True
2261         llvm_only = True
2262
2263 primop FloatX4SubOp "minusFloatX4#" Dyadic
2264   FloatX4# -> FloatX4# -> FloatX4#
2265    with llvm_only = True
2266
2267 primop FloatX4MulOp "timesFloatX4#" Dyadic    
2268    FloatX4# -> FloatX4# -> FloatX4#
2269    with commutable = True
2270         llvm_only = True
2271
2272 primop FloatX4DivOp "divideFloatX4#" Dyadic  
2273    FloatX4# -> FloatX4# -> FloatX4#
2274    with can_fail = True
2275         llvm_only = True
2276
2277 primop FloatX4NegOp "negateFloatX4#" Monadic
2278    FloatX4# -> FloatX4#
2279    with llvm_only = True
2280
2281 primop IndexByteArrayOp_FloatX4 "indexFloatX4Array#" GenPrimOp
2282    ByteArray# -> Int# -> FloatX4#
2283    with can_fail = True
2284         llvm_only = True
2285
2286 primop ReadByteArrayOp_FloatX4 "readFloatX4Array#" GenPrimOp
2287    MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatX4# #)
2288    with has_side_effects = True
2289         can_fail = True
2290         llvm_only = True
2291
2292 primop WriteByteArrayOp_FloatX4 "writeFloatX4Array#" GenPrimOp
2293    MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s
2294    with has_side_effects = True
2295         can_fail = True
2296         llvm_only = True
2297
2298 primop IndexOffAddrOp_FloatX4 "indexFloatX4OffAddr#" GenPrimOp
2299    Addr# -> Int# -> FloatX4#
2300    with can_fail = True
2301         llvm_only = True
2302
2303 primop ReadOffAddrOp_FloatX4 "readFloatX4OffAddr#" GenPrimOp
2304    Addr# -> Int# -> State# s -> (# State# s, FloatX4# #)
2305    with has_side_effects = True
2306         can_fail = True
2307         llvm_only = True
2308
2309 primop  WriteOffAddrOp_FloatX4 "writeFloatX4OffAddr#" GenPrimOp
2310    Addr# -> Int# -> FloatX4# -> State# s -> State# s
2311    with has_side_effects = True
2312         can_fail = True
2313         llvm_only = True
2314
2315 primop IndexByteArrayOp_FloatAsFloatX4 "indexFloatArrayAsFloatX4#" GenPrimOp
2316    ByteArray# -> Int# -> FloatX4#
2317    with can_fail = True
2318         llvm_only = True
2319
2320 primop ReadByteArrayOp_FloatAsFloatX4 "readFloatArrayAsFloatX4#" GenPrimOp
2321    MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatX4# #)
2322    with has_side_effects = True
2323         can_fail = True
2324         llvm_only = True
2325
2326 primop WriteByteArrayOp_FloatAsFloatX4 "writeFloatArrayAsFloatX4#" GenPrimOp
2327    MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s
2328    with has_side_effects = True
2329         can_fail = True
2330         llvm_only = True
2331
2332 primop IndexOffAddrOp_FloatAsFloatX4 "indexFloatOffAddrAsFloatX4#" GenPrimOp
2333    Addr# -> Int# -> FloatX4#
2334    with can_fail = True
2335         llvm_only = True
2336
2337 primop ReadOffAddrOp_FloatAsFloatX4 "readFloatOffAddrAsFloatX4#" GenPrimOp
2338    Addr# -> Int# -> State# s -> (# State# s, FloatX4# #)
2339    with has_side_effects = True
2340         can_fail = True
2341         llvm_only = True
2342
2343 primop  WriteOffAddrOp_FloatAsFloatX4 "writeFloatOffAddrAsFloatX4#" GenPrimOp
2344    Addr# -> Int# -> FloatX4# -> State# s -> State# s
2345    with has_side_effects = True
2346         can_fail = True
2347         llvm_only = True
2348
2349 ------------------------------------------------------------------------
2350 section "Double SIMD Vectors" 
2351         {Operations on SIMD vectors of 2 double-precision (64-bit)
2352          floating-point numbers.}
2353 ------------------------------------------------------------------------
2354
2355 primtype DoubleX2#
2356    with llvm_only = True
2357
2358 primop DoubleToDoubleX2Op "doubleToDoubleX2#" GenPrimOp     
2359    Double# -> DoubleX2#
2360    with llvm_only = True
2361
2362 primop DoubleX2InsertOp "insertDoubleX2#" GenPrimOp     
2363    DoubleX2# -> Double# -> Int# -> DoubleX2#
2364    with can_fail = True
2365         llvm_only = True
2366
2367 primop DoubleX2PackOp "packDoubleX2#" GenPrimOp         
2368    Double# -> Double# -> DoubleX2#
2369    with llvm_only = True
2370
2371 primop DoubleX2UnpackOp "unpackDoubleX2#" GenPrimOp         
2372    DoubleX2# -> (# Double#, Double# #)
2373    with llvm_only = True
2374
2375 primop DoubleX2AddOp "plusDoubleX2#" Dyadic            
2376    DoubleX2# -> DoubleX2# -> DoubleX2#
2377    with commutable = True
2378         llvm_only = True
2379
2380 primop DoubleX2SubOp "minusDoubleX2#" Dyadic
2381   DoubleX2# -> DoubleX2# -> DoubleX2#
2382    with llvm_only = True
2383
2384 primop DoubleX2MulOp "timesDoubleX2#" Dyadic    
2385    DoubleX2# -> DoubleX2# -> DoubleX2#
2386    with commutable = True
2387         llvm_only = True
2388
2389 primop DoubleX2DivOp "divideDoubleX2#" Dyadic  
2390    DoubleX2# -> DoubleX2# -> DoubleX2#
2391    with can_fail = True
2392         llvm_only = True
2393
2394 primop DoubleX2NegOp "negateDoubleX2#" Monadic
2395    DoubleX2# -> DoubleX2#
2396    with llvm_only = True
2397
2398 primop IndexByteArrayOp_DoubleX2 "indexDoubleX2Array#" GenPrimOp
2399    ByteArray# -> Int# -> DoubleX2#
2400    with can_fail = True
2401         llvm_only = True
2402
2403 primop ReadByteArrayOp_DoubleX2 "readDoubleX2Array#" GenPrimOp
2404    MutableByteArray# s -> Int# -> State# s -> (# State# s, DoubleX2# #)
2405    with has_side_effects = True
2406         can_fail = True
2407         llvm_only = True
2408
2409 primop WriteByteArrayOp_DoubleX2 "writeDoubleX2Array#" GenPrimOp
2410    MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s
2411    with has_side_effects = True
2412         can_fail = True
2413         llvm_only = True
2414
2415 primop IndexOffAddrOp_DoubleX2 "indexDoubleX2OffAddr#" GenPrimOp
2416    Addr# -> Int# -> DoubleX2#
2417    with can_fail = True
2418         llvm_only = True
2419
2420 primop ReadOffAddrOp_DoubleX2 "readDoubleX2OffAddr#" GenPrimOp
2421    Addr# -> Int# -> State# s -> (# State# s, DoubleX2# #)
2422    with has_side_effects = True
2423         can_fail = True
2424         llvm_only = True
2425
2426 primop  WriteOffAddrOp_DoubleX2 "writeDoubleX2OffAddr#" GenPrimOp
2427    Addr# -> Int# -> DoubleX2# -> State# s -> State# s
2428    with has_side_effects = True
2429         can_fail = True
2430         llvm_only = True
2431
2432 primop IndexByteArrayOp_DoubleAsDoubleX2 "indexDoubleArrayAsDoubleX2#" GenPrimOp
2433    ByteArray# -> Int# -> DoubleX2#
2434    with can_fail = True
2435         llvm_only = True
2436
2437 primop ReadByteArrayOp_DoubleAsDoubleX2 "readDoubleArrayAsDoubleX2#" GenPrimOp
2438    MutableByteArray# s -> Int# -> State# s -> (# State# s, DoubleX2# #)
2439    with has_side_effects = True
2440         can_fail = True
2441         llvm_only = True
2442
2443 primop WriteByteArrayOp_DoubleAsDoubleX2 "writeDoubleArrayAsDoubleX2#" GenPrimOp
2444    MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s
2445    with has_side_effects = True
2446         can_fail = True
2447         llvm_only = True
2448
2449 primop IndexOffAddrOp_DoubleAsDoubleX2 "indexDoubleOffAddrAsDoubleX2#" GenPrimOp
2450    Addr# -> Int# -> DoubleX2#
2451    with can_fail = True
2452         llvm_only = True
2453
2454 primop ReadOffAddrOp_DoubleAsDoubleX2 "readDoubleOffAddrAsDoubleX2#" GenPrimOp
2455    Addr# -> Int# -> State# s -> (# State# s, DoubleX2# #)
2456    with has_side_effects = True
2457         can_fail = True
2458         llvm_only = True
2459
2460 primop  WriteOffAddrOp_DoubleAsDoubleX2 "writeDoubleOffAddrAsDoubleX2#" GenPrimOp
2461    Addr# -> Int# -> DoubleX2# -> State# s -> State# s
2462    with has_side_effects = True
2463         can_fail = True
2464         llvm_only = True
2465
2466 ------------------------------------------------------------------------
2467 section "Int32 SIMD Vectors" 
2468         {Operations on SIMD vectors of 4 32-bit signed integers.}
2469 ------------------------------------------------------------------------
2470
2471 primtype Int32X4#
2472    with llvm_only = True
2473
2474 primop Int32ToInt32X4Op "int32ToInt32X4#" GenPrimOp     
2475    INT32 -> Int32X4#
2476    with llvm_only = True
2477
2478 primop Int32X4InsertOp "insertInt32X4#" GenPrimOp     
2479    Int32X4# -> INT32 -> Int# -> Int32X4#
2480    with can_fail = True
2481         llvm_only = True
2482
2483 primop Int32X4PackOp "packInt32X4#" GenPrimOp         
2484    INT32 -> INT32 -> INT32 -> INT32 -> Int32X4#
2485    with llvm_only = True
2486
2487 primop Int32X4UnpackOp "unpackInt32X4#" GenPrimOp         
2488    Int32X4# -> (# INT32, INT32, INT32, INT32 #)
2489    with llvm_only = True
2490
2491 primop Int32X4AddOp "plusInt32X4#" Dyadic            
2492    Int32X4# -> Int32X4# -> Int32X4#
2493    with commutable = True
2494         llvm_only = True
2495
2496 primop Int32X4SubOp "minusInt32X4#" Dyadic
2497   Int32X4# -> Int32X4# -> Int32X4#
2498    with llvm_only = True
2499
2500 primop Int32X4MulOp "timesInt32X4#" Dyadic    
2501    Int32X4# -> Int32X4# -> Int32X4#
2502    with commutable = True
2503         llvm_only = True
2504
2505 primop Int32X4QuotOp "quotInt32X4#" Dyadic  
2506    Int32X4# -> Int32X4# -> Int32X4#
2507    with can_fail = True
2508         llvm_only = True
2509    
2510 primop Int32X4RemOp "remInt32X4#" Dyadic  
2511    Int32X4# -> Int32X4# -> Int32X4#
2512    with can_fail = True
2513         llvm_only = True
2514
2515 primop Int32X4NegOp "negateInt32X4#" Monadic
2516    Int32X4# -> Int32X4#
2517    with llvm_only = True
2518
2519 primop IndexByteArrayOp_Int32X4 "indexInt32X4Array#" GenPrimOp
2520    ByteArray# -> Int# -> Int32X4#
2521    with can_fail = True
2522         llvm_only = True
2523
2524 primop ReadByteArrayOp_Int32X4 "readInt32X4Array#" GenPrimOp
2525    MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32X4# #)
2526    with has_side_effects = True
2527         can_fail = True
2528         llvm_only = True
2529
2530 primop WriteByteArrayOp_Int32X4 "writeInt32X4Array#" GenPrimOp
2531    MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s
2532    with has_side_effects = True
2533         can_fail = True
2534         llvm_only = True
2535
2536 primop IndexOffAddrOp_Int32X4 "indexInt32X4OffAddr#" GenPrimOp
2537    Addr# -> Int# -> Int32X4#
2538    with can_fail = True
2539         llvm_only = True
2540
2541 primop ReadOffAddrOp_Int32X4 "readInt32X4OffAddr#" GenPrimOp
2542    Addr# -> Int# -> State# s -> (# State# s, Int32X4# #)
2543    with has_side_effects = True
2544         can_fail = True
2545         llvm_only = True
2546
2547 primop  WriteOffAddrOp_Int32X4 "writeInt32X4OffAddr#" GenPrimOp
2548    Addr# -> Int# -> Int32X4# -> State# s -> State# s
2549    with has_side_effects = True
2550         can_fail = True
2551         llvm_only = True
2552
2553 primop IndexByteArrayOp_Int32AsInt32X4 "indexInt32ArrayAsInt32X4#" GenPrimOp
2554    ByteArray# -> Int# -> Int32X4#
2555    with can_fail = True
2556         llvm_only = True
2557
2558 primop ReadByteArrayOp_Int32AsInt32X4 "readInt32ArrayAsInt32X4#" GenPrimOp
2559    MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32X4# #)
2560    with has_side_effects = True
2561         can_fail = True
2562         llvm_only = True
2563
2564 primop WriteByteArrayOp_Int32AsInt32X4 "writeInt32ArrayAsInt32X4#" GenPrimOp
2565    MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s
2566    with has_side_effects = True
2567         can_fail = True
2568         llvm_only = True
2569
2570 primop IndexOffAddrOp_Int32AsInt32X4 "indexInt32OffAddrAsInt32X4#" GenPrimOp
2571    Addr# -> Int# -> Int32X4#
2572    with can_fail = True
2573         llvm_only = True
2574
2575 primop ReadOffAddrOp_Int32AsInt32X4 "readInt32OffAddrAsInt32X4#" GenPrimOp
2576    Addr# -> Int# -> State# s -> (# State# s, Int32X4# #)
2577    with has_side_effects = True
2578         can_fail = True
2579         llvm_only = True
2580
2581 primop  WriteOffAddrOp_Int32AsInt32X4 "writeInt32OffAddrAsInt32X4#" GenPrimOp
2582    Addr# -> Int# -> Int32X4# -> State# s -> State# s
2583    with has_side_effects = True
2584         can_fail = True
2585         llvm_only = True
2586
2587 ------------------------------------------------------------------------
2588 section "Int64 SIMD Vectors" 
2589         {Operations on SIMD vectors of 2 64-bit signed integers.}
2590 ------------------------------------------------------------------------
2591
2592 primtype Int64X2#
2593    with llvm_only = True
2594
2595 primop Int64ToInt64X2Op "int64ToInt64X2#" GenPrimOp     
2596    INT64 -> Int64X2#
2597    with llvm_only = True
2598
2599 primop Int64X2InsertOp "insertInt64X2#" GenPrimOp     
2600    Int64X2# -> INT64 -> Int# -> Int64X2#
2601    with can_fail = True
2602         llvm_only = True
2603
2604 primop Int64X2PackOp "packInt64X2#" GenPrimOp         
2605    INT64 -> INT64 -> Int64X2#
2606    with llvm_only = True
2607
2608 primop Int64X2UnpackOp "unpackInt64X2#" GenPrimOp         
2609    Int64X2# -> (# INT64, INT64 #)
2610    with llvm_only = True
2611
2612 primop Int64X2AddOp "plusInt64X2#" Dyadic            
2613    Int64X2# -> Int64X2# -> Int64X2#
2614    with commutable = True
2615         llvm_only = True
2616
2617 primop Int64X2SubOp "minusInt64X2#" Dyadic
2618   Int64X2# -> Int64X2# -> Int64X2#
2619    with llvm_only = True
2620
2621 primop Int64X2MulOp "timesInt64X2#" Dyadic    
2622    Int64X2# -> Int64X2# -> Int64X2#
2623    with commutable = True
2624         llvm_only = True
2625
2626 primop Int64X2QuotOp "quotInt64X2#" Dyadic  
2627    Int64X2# -> Int64X2# -> Int64X2#
2628    with can_fail = True
2629         llvm_only = True
2630    
2631 primop Int64X2RemOp "remInt64X2#" Dyadic  
2632    Int64X2# -> Int64X2# -> Int64X2#
2633    with can_fail = True
2634         llvm_only = True
2635
2636 primop Int64X2NegOp "negateInt64X2#" Monadic
2637    Int64X2# -> Int64X2#
2638    with llvm_only = True
2639
2640 primop IndexByteArrayOp_Int64X2 "indexInt64X2Array#" GenPrimOp
2641    ByteArray# -> Int# -> Int64X2#
2642    with can_fail = True
2643         llvm_only = True
2644
2645 primop ReadByteArrayOp_Int64X2 "readInt64X2Array#" GenPrimOp
2646    MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64X2# #)
2647    with has_side_effects = True
2648         can_fail = True
2649         llvm_only = True
2650
2651 primop WriteByteArrayOp_Int64X2 "writeInt64X2Array#" GenPrimOp
2652    MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s
2653    with has_side_effects = True
2654         can_fail = True
2655         llvm_only = True
2656
2657 primop IndexOffAddrOp_Int64X2 "indexInt64X2OffAddr#" GenPrimOp
2658    Addr# -> Int# -> Int64X2#
2659    with can_fail = True
2660         llvm_only = True
2661
2662 primop ReadOffAddrOp_Int64X2 "readInt64X2OffAddr#" GenPrimOp
2663    Addr# -> Int# -> State# s -> (# State# s, Int64X2# #)
2664    with has_side_effects = True
2665         llvm_only = True
2666
2667 primop  WriteOffAddrOp_Int64X2 "writeInt64X2OffAddr#" GenPrimOp
2668    Addr# -> Int# -> Int64X2# -> State# s -> State# s
2669    with has_side_effects = True
2670         can_fail = True
2671         llvm_only = True
2672
2673 primop IndexByteArrayOp_Int64AsInt64X2 "indexInt64ArrayAsInt64X2#" GenPrimOp
2674    ByteArray# -> Int# -> Int64X2#
2675    with can_fail = True
2676         llvm_only = True
2677
2678 primop ReadByteArrayOp_Int64AsInt64X2 "readInt64ArrayAsInt64X2#" GenPrimOp
2679    MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64X2# #)
2680    with has_side_effects = True
2681         can_fail = True
2682         llvm_only = True
2683
2684 primop WriteByteArrayOp_Int64AsInt64X2 "writeInt64ArrayAsInt64X2#" GenPrimOp
2685    MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s
2686    with has_side_effects = True
2687         can_fail = True
2688         llvm_only = True
2689
2690 primop IndexOffAddrOp_Int64AsInt64X2 "indexInt64OffAddrAsInt64X2#" GenPrimOp
2691    Addr# -> Int# -> Int64X2#
2692    with can_fail = True
2693         llvm_only = True
2694
2695 primop ReadOffAddrOp_Int64AsInt64X2 "readInt64OffAddrAsInt64X2#" GenPrimOp
2696    Addr# -> Int# -> State# s -> (# State# s, Int64X2# #)
2697    with has_side_effects = True
2698         can_fail = True
2699         llvm_only = True
2700
2701 primop  WriteOffAddrOp_Int64AsInt64X2 "writeInt64OffAddrAsInt64X2#" GenPrimOp
2702    Addr# -> Int# -> Int64X2# -> State# s -> State# s
2703    with has_side_effects = True
2704         can_fail = True
2705         llvm_only = True
2706    
2707 ------------------------------------------------------------------------
2708 section "Prefetch" 
2709         {Prefetch operations}
2710 ------------------------------------------------------------------------
2711
2712 primop PrefetchByteArrayOp "prefetchByteArray#" GenPrimOp
2713    ByteArray# -> Int# -> ByteArray#
2714    with llvm_only = True
2715
2716 primop PrefetchMutableByteArrayOp "prefetchMutableByteArray#" GenPrimOp
2717    MutableByteArray# s -> Int# -> State# s -> State# s
2718    with has_side_effects = True
2719         llvm_only = True
2720
2721 primop PrefetchAddrOp "prefetchAddr#" GenPrimOp
2722    Addr# -> Int# -> Addr#
2723    with llvm_only = True
2724
2725 ------------------------------------------------------------------------
2726 ---                                                                  ---
2727 ------------------------------------------------------------------------
2728
2729 thats_all_folks