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