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