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