X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fprelude%2Fprimops.txt.pp;h=cd2f25cffec7ff3fac6b909f77cd1fcc65edab32;hb=75d52d81c0256e7bd2ae5108fc611224ea08edda;hp=7d6b000715111f2bdc7038b5991dd738c4a9e710;hpb=fd94f66371dfd4a2c6694d933374a3a5aa7bd7b4;p=ghc-hetmet.git diff --git a/ghc/compiler/prelude/primops.txt.pp b/ghc/compiler/prelude/primops.txt.pp index 7d6b000..cd2f25c 100644 --- a/ghc/compiler/prelude/primops.txt.pp +++ b/ghc/compiler/prelude/primops.txt.pp @@ -1,5 +1,5 @@ ----------------------------------------------------------------------- --- $Id: primops.txt.pp,v 1.8 2001/10/17 11:26:04 simonpj Exp $ +-- $Id: primops.txt.pp,v 1.33 2005/03/04 19:19:56 sof Exp $ -- -- Primitive Operations -- @@ -18,16 +18,15 @@ -- strictness attributes, whether it is defined as a macro -- or as out-of-line code, etc.) -- --- - ghc/lib/std/PrelGHC.hi-boot, to declare the primop --- -- - if the primop is inline (i.e. a macro), then: --- ghc/includes/PrimOps.h --- ghc/compiler/nativeGen/StixPrim.lhs --- ghc/compiler/nativeGen/MachCode.lhs (if implementation is machine-dependent) +-- ghc/compiler/AbsCUtils.lhs (dscCOpStmt) +-- defines the translation of the primop into simpler +-- abstract C operations. -- -- - or, for an out-of-line primop: -- ghc/includes/PrimOps.h (just add the declaration) -- ghc/rts/PrimOps.hc (define it here) +-- ghc/rts/Linker.c (declare the symbol for GHCi) -- -- - the User's Guide -- @@ -57,7 +56,7 @@ defaults commutable = False needs_wrapper = False can_fail = False - strictness = { \ arity -> StrictnessInfo (replicate arity wwPrim) False } + strictness = { \ arity -> mkStrictSig (mkTopDmdType (replicate arity lazyDmd) TopRes) } usage = { nomangle other } -- Currently, documentation is produced using latex, so contents of @@ -65,6 +64,7 @@ defaults -- matched pairs of embedded curly brackets. #include "MachDeps.h" +#include "ghcconfig.h" section "The word size story." {Haskell98 specifies that signed integers (type {\tt Int}) @@ -180,6 +180,31 @@ primop IntSubOp "-#" Dyadic Int# -> Int# -> Int# primop IntMulOp "*#" Dyadic Int# -> Int# -> Int# + {Low word of signed integer multiply.} + with commutable = True + +primop IntMulMayOfloOp "mulIntMayOflo#" + Dyadic Int# -> Int# -> Int# + {Return non-zero if there is any possibility that the upper word of a + signed integer multiply might contain useful information. Return + zero only if you are completely sure that no overflow can occur. + On a 32-bit platform, the recommmended implementation is to do a + 32 x 32 -> 64 signed multiply, and subtract result[63:32] from + (result[31] >>signed 31). If this is zero, meaning that the + upper word is merely a sign extension of the lower one, no + overflow can occur. + + On a 64-bit platform it is not always possible to + acquire the top 64 bits of the result. Therefore, a recommended + implementation is to take the absolute value of both operands, and + return 0 iff bits[63:31] of them are zero, since that means that their + magnitudes fit within 31 bits, so the magnitude of the product must fit + into 62 bits. + + If in doubt, return non-zero, but do make an effort to create the + correct answer for small args, since otherwise the performance of + (*) :: Integer -> Integer -> Integer will be poor. + } with commutable = True primop IntQuotOp "quotInt#" Dyadic @@ -193,13 +218,16 @@ primop IntRemOp "remInt#" Dyadic with can_fail = True primop IntGcdOp "gcdInt#" Dyadic Int# -> Int# -> Int# + with out_of_line = True + primop IntNegOp "negateInt#" Monadic Int# -> Int# primop IntAddCOp "addIntC#" GenPrimOp Int# -> Int# -> (# Int#, Int# #) - {Add with carry. First member of result is (wrapped) sum; second member is 0 iff no overflow occured.} + {Add with carry. First member of result is (wrapped) sum; + second member is 0 iff no overflow occured.} primop IntSubCOp "subIntC#" GenPrimOp Int# -> Int# -> (# Int#, Int# #) - {Subtract with carry. First member of result is (wrapped) difference; second member is 0 iff no overflow occured.} -primop IntMulCOp "mulIntC#" GenPrimOp Int# -> Int# -> (# Int#, Int# #) - {Multiply with carry. First member of result is (wrapped) product; second member is 0 iff no overflow occured.} + {Subtract with carry. First member of result is (wrapped) difference; + second member is 0 iff no overflow occured.} + primop IntGtOp ">#" Compare Int# -> Int# -> Bool primop IntGeOp ">=#" Compare Int# -> Int# -> Bool @@ -224,12 +252,15 @@ primop Int2IntegerOp "int2Integer#" GenPrimOp Int# -> (# Int#, ByteArr# #) with out_of_line = True -primop ISllOp "iShiftL#" GenPrimOp Int# -> Int# -> Int# - {Shift left. Return 0 if shifted by more than size of an Int\#.} -primop ISraOp "iShiftRA#" GenPrimOp Int# -> Int# -> Int# - {Shift right arithemetic. Return 0 if shifted by more than size of an Int\#.} -primop ISrlOp "iShiftRL#" GenPrimOp Int# -> Int# -> Int# - {Shift right logical. Return 0 if shifted by more than size of an Int\#.} +primop ISllOp "uncheckedIShiftL#" GenPrimOp Int# -> Int# -> Int# + {Shift left. Result undefined if shift amount is not + in the range 0 to word size - 1 inclusive.} +primop ISraOp "uncheckedIShiftRA#" GenPrimOp Int# -> Int# -> Int# + {Shift right arithmetic. Result undefined if shift amount is not + in the range 0 to word size - 1 inclusive.} +primop ISrlOp "uncheckedIShiftRL#" GenPrimOp Int# -> Int# -> Int# + {Shift right logical. Result undefined if shift amount is not + in the range 0 to word size - 1 inclusive.} ------------------------------------------------------------------------ section "Word#" @@ -261,10 +292,12 @@ primop XorOp "xor#" Dyadic Word# -> Word# -> Word# primop NotOp "not#" Monadic Word# -> Word# -primop SllOp "shiftL#" GenPrimOp Word# -> Int# -> Word# - {Shift left logical. Return 0 if shifted by more than number of bits in a Word\#.} -primop SrlOp "shiftRL#" GenPrimOp Word# -> Int# -> Word# - {Shift right logical. Return 0 if shifted by more than number of bits in a Word\#.} +primop SllOp "uncheckedShiftL#" GenPrimOp Word# -> Int# -> Word# + {Shift left logical. Result undefined if shift amount is not + in the range 0 to word size - 1 inclusive.} +primop SrlOp "uncheckedShiftRL#" GenPrimOp Word# -> Int# -> Word# + {Shift right logical. Result undefined if shift amount is not + in the range 0 to word size - 1 inclusive.} primop Word2IntOp "word2Int#" GenPrimOp Word# -> Int# @@ -351,9 +384,15 @@ section "Integer#" implemented via the GMP package. An integer is represented as a pair consisting of an Int\# representing the number of 'limbs' in use and the sign, and a ByteArr\# containing the 'limbs' themselves. Such pairs -are returned as unboxed pairs, but must be passed as separate components.} +are returned as unboxed pairs, but must be passed as separate +components. + +For .NET these operations are implemented by foreign imports, so the +primops are omitted.} ------------------------------------------------------------------------ +#ifndef ILX + primop IntegerAddOp "plusInteger#" GenPrimOp Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #) with commutable = True @@ -377,7 +416,7 @@ primop IntegerGcdOp "gcdInteger#" GenPrimOp primop IntegerIntGcdOp "gcdIntegerInt#" GenPrimOp Int# -> ByteArr# -> Int# -> Int# {Greatest common divisor, where second argument is an ordinary Int\#.} - -- with commutable = True (surely not? APT 8/01) + with out_of_line = True primop IntegerDivExactOp "divExactInteger#" GenPrimOp Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #) @@ -398,12 +437,14 @@ primop IntegerCmpOp "cmpInteger#" GenPrimOp Int# -> ByteArr# -> Int# -> ByteArr# -> Int# {Returns -1,0,1 according as first argument is less than, equal to, or greater than second argument.} with needs_wrapper = True + out_of_line = True primop IntegerCmpIntOp "cmpIntegerInt#" GenPrimOp Int# -> ByteArr# -> Int# -> Int# {Returns -1,0,1 according as first argument is less than, equal to, or greater than second argument, which is an ordinary Int\#.} with needs_wrapper = True + out_of_line = True primop IntegerQuotRemOp "quotRemInteger#" GenPrimOp Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr#, Int#, ByteArr# #) @@ -421,10 +462,12 @@ primop IntegerDivModOp "divModInteger#" GenPrimOp primop Integer2IntOp "integer2Int#" GenPrimOp Int# -> ByteArr# -> Int# with needs_wrapper = True + out_of_line = True primop Integer2WordOp "integer2Word#" GenPrimOp Int# -> ByteArr# -> Word# with needs_wrapper = True + out_of_line = True #if WORD_SIZE_IN_BITS < 32 primop IntegerToInt32Op "integerToInt32#" GenPrimOp @@ -434,14 +477,6 @@ primop IntegerToWord32Op "integerToWord32#" GenPrimOp Int# -> ByteArr# -> Word32# #endif -#if WORD_SIZE_IN_BITS < 64 -primop IntegerToInt64Op "integerToInt64#" GenPrimOp - Int# -> ByteArr# -> Int64# - -primop IntegerToWord64Op "integerToWord64#" GenPrimOp - Int# -> ByteArr# -> Word64# -#endif - primop IntegerAndOp "andInteger#" GenPrimOp Int# -> ByteArr# -> Int# -> ByteArr# -> (# Int#, ByteArr# #) with out_of_line = True @@ -458,6 +493,7 @@ primop IntegerComplementOp "complementInteger#" GenPrimOp Int# -> ByteArr# -> (# Int#, ByteArr# #) with out_of_line = True +#endif /* ndef ILX */ ------------------------------------------------------------------------ section "Double#" @@ -676,7 +712,6 @@ primop NewArrayOp "newArray#" GenPrimOp in the specified state thread, with each element containing the specified initial value.} with - strictness = { \ arity -> StrictnessInfo [wwPrim, wwLazy, wwPrim] False } usage = { mangle NewArrayOp [mkP, mkM, mkP] mkM } out_of_line = True @@ -696,7 +731,6 @@ primop WriteArrayOp "writeArray#" GenPrimOp {Write to specified index of mutable array.} with usage = { mangle WriteArrayOp [mkM, mkP, mkM, mkP] mkR } - strictness = { \ arity -> StrictnessInfo [wwPrim, wwPrim, wwLazy, wwPrim] False } has_side_effects = True primop IndexArrayOp "indexArray#" GenPrimOp @@ -1154,7 +1188,6 @@ primop TouchOp "touch#" GenPrimOp o -> State# RealWorld -> State# RealWorld with has_side_effects = True - strictness = { \ arity -> StrictnessInfo [wwLazy, wwPrim] False } primop EqForeignObj "eqForeignObj#" GenPrimOp ForeignObj# -> ForeignObj# -> Bool @@ -1222,7 +1255,6 @@ primop NewMutVarOp "newMutVar#" GenPrimOp {Create MutVar\# with specified initial value in specified state thread.} with usage = { mangle NewMutVarOp [mkM, mkP] mkM } - strictness = { \ arity -> StrictnessInfo [wwLazy, wwPrim] False } out_of_line = True primop ReadMutVarOp "readMutVar#" GenPrimOp @@ -1235,7 +1267,6 @@ primop WriteMutVarOp "writeMutVar#" GenPrimOp MutVar# s a -> a -> State# s -> State# s {Write contents of MutVar\#.} with - strictness = { \ arity -> StrictnessInfo [wwPrim, wwLazy, wwPrim] False } usage = { mangle WriteMutVarOp [mkM, mkM, mkP] mkR } has_side_effects = True @@ -1244,6 +1275,18 @@ primop SameMutVarOp "sameMutVar#" GenPrimOp with usage = { mangle SameMutVarOp [mkP, mkP] mkM } +-- not really the right type, but we don't know about pairs here. The +-- correct type is +-- +-- MutVar# s a -> (a -> (a,b)) -> State# s -> (# State# s, b #) +-- +primop AtomicModifyMutVarOp "atomicModifyMutVar#" GenPrimOp + MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #) + with + usage = { mangle AtomicModifyMutVarOp [mkP, mkM, mkP] mkM } + has_side_effects = True + out_of_line = True + ------------------------------------------------------------------------ section "Exceptions" ------------------------------------------------------------------------ @@ -1254,7 +1297,6 @@ primop CatchOp "catch#" GenPrimOp -> State# RealWorld -> (# State# RealWorld, a #) with - strictness = { \ arity -> StrictnessInfo [wwLazy, wwLazy, wwPrim] False } -- Catch is actually strict in its first argument -- but we don't want to tell the strictness -- analyser about that! @@ -1266,26 +1308,93 @@ primop CatchOp "catch#" GenPrimOp primop RaiseOp "raise#" GenPrimOp a -> b with - strictness = { \ arity -> StrictnessInfo [wwLazy] True } - -- NB: True => result is bottom + strictness = { \ arity -> mkStrictSig (mkTopDmdType [lazyDmd] BotRes) } + -- NB: result is bottom usage = { mangle RaiseOp [mkM] mkM } out_of_line = True +-- raiseIO# needs to be a primop, because exceptions in the IO monad +-- must be *precise* - we don't want the strictness analyser turning +-- one kind of bottom into another, as it is allowed to do in pure code. + +primop RaiseIOOp "raiseIO#" GenPrimOp + a -> State# RealWorld -> (# State# RealWorld, b #) + with + out_of_line = True + primop BlockAsyncExceptionsOp "blockAsyncExceptions#" GenPrimOp (State# RealWorld -> (# State# RealWorld, a #)) -> (State# RealWorld -> (# State# RealWorld, a #)) with - strictness = { \ arity -> StrictnessInfo [wwLazy, wwPrim] False } out_of_line = True primop UnblockAsyncExceptionsOp "unblockAsyncExceptions#" GenPrimOp (State# RealWorld -> (# State# RealWorld, a #)) -> (State# RealWorld -> (# State# RealWorld, a #)) with - strictness = { \ arity -> StrictnessInfo [wwLazy, wwPrim] False } out_of_line = True ------------------------------------------------------------------------ +section "STM-accessible Mutable Variables" +------------------------------------------------------------------------ + +primop AtomicallyOp "atomically#" GenPrimOp + (State# RealWorld -> (# State# RealWorld, a #) ) + -> State# RealWorld -> (# State# RealWorld, a #) + with + out_of_line = True + has_side_effects = True + +primop RetryOp "retry#" GenPrimOp + State# RealWorld -> (# State# RealWorld, a #) + with + out_of_line = True + has_side_effects = True + +primop CatchRetryOp "catchRetry#" GenPrimOp + (State# RealWorld -> (# State# RealWorld, a #) ) + -> (State# RealWorld -> (# State# RealWorld, a #) ) + -> (State# RealWorld -> (# State# RealWorld, a #) ) + with + out_of_line = True + has_side_effects = True + +primop CatchSTMOp "catchSTM#" GenPrimOp + (State# RealWorld -> (# State# RealWorld, a #) ) + -> (b -> State# RealWorld -> (# State# RealWorld, a #) ) + -> (State# RealWorld -> (# State# RealWorld, a #) ) + with + out_of_line = True + has_side_effects = True + +primop NewTVarOp "newTVar#" GenPrimOp + a + -> State# s -> (# State# s, TVar# s a #) + {Create a new Tar\# holding a specified initial value.} + with + out_of_line = True + +primop ReadTVarOp "readTVar#" GenPrimOp + TVar# s a + -> State# s -> (# State# s, a #) + {Read contents of TVar\#. Result is not yet evaluated.} + with + out_of_line = True + +primop WriteTVarOp "writeTVar#" GenPrimOp + TVar# s a + -> a + -> State# s -> State# s + {Write contents of TVar\#.} + with + out_of_line = True + has_side_effects = True + +primop SameTVarOp "sameTVar#" GenPrimOp + TVar# s a -> TVar# s a -> Bool + + +------------------------------------------------------------------------ section "Synchronized Mutable Variables" {Operations on MVar\#s, which are shared mutable variables ({\it not} the same as MutVar\#s!). (Note: in a non-concurrent implementation, @@ -1323,7 +1432,6 @@ primop PutMVarOp "putMVar#" GenPrimOp {If mvar is full, block until it becomes empty. Then store value arg as its new contents.} with - strictness = { \ arity -> StrictnessInfo [wwPrim, wwLazy, wwPrim] False } usage = { mangle PutMVarOp [mkM, mkM, mkP] mkR } has_side_effects = True out_of_line = True @@ -1333,7 +1441,6 @@ primop TryPutMVarOp "tryPutMVar#" GenPrimOp {If mvar is full, immediately return with integer 0. Otherwise, store value arg as mvar's new contents, and return with integer 1.} with - strictness = { \ arity -> StrictnessInfo [wwPrim, wwLazy, wwPrim] False } usage = { mangle TryPutMVarOp [mkM, mkM, mkP] mkR } has_side_effects = True out_of_line = True @@ -1348,7 +1455,7 @@ primop IsEmptyMVarOp "isEmptyMVar#" GenPrimOp {Return 1 if mvar is empty; 0 otherwise.} with usage = { mangle IsEmptyMVarOp [mkP, mkP] mkM } - + out_of_line = True ------------------------------------------------------------------------ section "Delay/wait operations" @@ -1378,6 +1485,33 @@ primop WaitWriteOp "waitWrite#" GenPrimOp has_side_effects = True out_of_line = True +#ifdef mingw32_TARGET_OS +primop AsyncReadOp "asyncRead#" GenPrimOp + Int# -> Int# -> Int# -> Addr# -> State# RealWorld-> (# State# RealWorld, Int#, Int# #) + {Asynchronously read bytes from specified file descriptor.} + with + needs_wrapper = True + has_side_effects = True + out_of_line = True + +primop AsyncWriteOp "asyncWrite#" GenPrimOp + Int# -> Int# -> Int# -> Addr# -> State# RealWorld-> (# State# RealWorld, Int#, Int# #) + {Asynchronously write bytes from specified file descriptor.} + with + needs_wrapper = True + has_side_effects = True + out_of_line = True + +primop AsyncDoProcOp "asyncDoProc#" GenPrimOp + Addr# -> Addr# -> State# RealWorld-> (# State# RealWorld, Int#, Int# #) + {Asynchronously perform procedure (first arg), passing it 2nd arg.} + with + needs_wrapper = True + has_side_effects = True + out_of_line = True + +#endif + ------------------------------------------------------------------------ section "Concurrency primitives" {(In a non-concurrent implementation, ThreadId\# can be as singleton @@ -1389,7 +1523,6 @@ primop ForkOp "fork#" GenPrimOp a -> State# RealWorld -> (# State# RealWorld, ThreadId# #) with usage = { mangle ForkOp [mkO, mkP] mkR } - strictness = { \ arity -> StrictnessInfo [wwLazy, wwPrim] False } has_side_effects = True out_of_line = True @@ -1407,7 +1540,20 @@ primop YieldOp "yield#" GenPrimOp out_of_line = True primop MyThreadIdOp "myThreadId#" GenPrimOp - State# RealWorld -> (# State# RealWorld, ThreadId# #) + State# RealWorld -> (# State# RealWorld, ThreadId# #) + with + out_of_line = True + +primop LabelThreadOp "labelThread#" GenPrimOp + ThreadId# -> Addr# -> State# RealWorld -> State# RealWorld + with + has_side_effects = True + out_of_line = True + +primop IsCurrentThreadBoundOp "isCurrentThreadBound#" GenPrimOp + State# RealWorld -> (# State# RealWorld, Int# #) + with + out_of_line = True ------------------------------------------------------------------------ section "Weak pointers" @@ -1418,7 +1564,6 @@ section "Weak pointers" primop MkWeakOp "mkWeak#" GenPrimOp o -> b -> c -> State# RealWorld -> (# State# RealWorld, Weak# b #) with - strictness = { \ arity -> StrictnessInfo [wwLazy, wwLazy, wwLazy, wwPrim] False } usage = { mangle MkWeakOp [mkZ, mkM, mkM, mkP] mkM } has_side_effects = True out_of_line = True @@ -1428,10 +1573,11 @@ primop DeRefWeakOp "deRefWeak#" GenPrimOp with usage = { mangle DeRefWeakOp [mkM, mkP] mkM } has_side_effects = True + out_of_line = True primop FinalizeWeakOp "finalizeWeak#" GenPrimOp Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, - (State# RealWorld -> (# State# RealWorld, Unit #)) #) + (State# RealWorld -> (# State# RealWorld, () #)) #) with usage = { mangle FinalizeWeakOp [mkM, mkP] (mkR . (inUB FinalizeWeakOp @@ -1446,9 +1592,9 @@ section "Stable pointers and names" primop MakeStablePtrOp "makeStablePtr#" GenPrimOp a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #) with - strictness = { \ arity -> StrictnessInfo [wwLazy, wwPrim] False } usage = { mangle MakeStablePtrOp [mkM, mkP] mkM } has_side_effects = True + out_of_line = True primop DeRefStablePtrOp "deRefStablePtr#" GenPrimOp StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #) @@ -1456,6 +1602,7 @@ primop DeRefStablePtrOp "deRefStablePtr#" GenPrimOp usage = { mangle DeRefStablePtrOp [mkM, mkP] mkM } needs_wrapper = True has_side_effects = True + out_of_line = True primop EqStablePtrOp "eqStablePtr#" GenPrimOp StablePtr# a -> StablePtr# a -> Int# @@ -1467,7 +1614,6 @@ primop MakeStableNameOp "makeStableName#" GenPrimOp a -> State# RealWorld -> (# State# RealWorld, StableName# a #) with usage = { mangle MakeStableNameOp [mkZ, mkP] mkR } - strictness = { \ arity -> StrictnessInfo [wwLazy, wwPrim] False } needs_wrapper = True has_side_effects = True out_of_line = True @@ -1496,19 +1642,10 @@ primop ReallyUnsafePtrEqualityOp "reallyUnsafePtrEquality#" GenPrimOp section "Parallelism" ------------------------------------------------------------------------ -primop SeqOp "seq#" GenPrimOp - a -> Int# - with - usage = { mangle SeqOp [mkO] mkR } - strictness = { \ arity -> StrictnessInfo [wwStrict] False } - -- Seq is strict in its argument; see notes in ConFold.lhs - has_side_effects = True - primop ParOp "par#" GenPrimOp a -> Int# with usage = { mangle ParOp [mkO] mkR } - strictness = { \ arity -> StrictnessInfo [wwLazy] False } -- Note that Par is lazy to avoid that the sparked thing -- gets evaluted strictly, which it should *not* be has_side_effects = True @@ -1579,7 +1716,8 @@ section "Tag to enum stuff" primop DataToTagOp "dataToTag#" GenPrimOp a -> Int# with - strictness = { \ arity -> StrictnessInfo [wwLazy] False } + strictness = { \ arity -> mkStrictSig (mkTopDmdType [seqDmd] TopRes) } + -- dataToTag# must have an evaluated argument primop TagToEnumOp "tagToEnum#" GenPrimOp Int# -> a @@ -1595,19 +1733,19 @@ primop AddrToHValueOp "addrToHValue#" GenPrimOp {Convert an Addr\# to a followable type.} primop MkApUpd0_Op "mkApUpd0#" GenPrimOp - a -> (# a #) + BCO# -> (# a #) with out_of_line = True primop NewBCOOp "newBCO#" GenPrimOp - ByteArr# -> ByteArr# -> Array# a -> ByteArr# -> State# s -> (# State# s, BCO# #) + ByteArr# -> ByteArr# -> Array# a -> ByteArr# -> Int# -> ByteArr# -> State# s -> (# State# s, BCO# #) with has_side_effects = True out_of_line = True ------------------------------------------------------------------------ section "Coercion" - {{\tt unsafeCoerce# :: a -> b} is not a primop, but is defined in MkId.lhs.} + {{\tt unsafeCoerce\# :: a -> b} is not a primop, but is defined in MkId.lhs.} ------------------------------------------------------------------------