pprPrimOp,
- CCall(..), CCallTarget(..), ccallMayGC, ccallIsCasm, pprCCallOp
+ CCall(..), CCallTarget(..), ccallMayGC, ccallIsCasm, pprCCallOp,
+ isDynamicTarget, dynamicTarget, setCCallUnique
) where
#include "HsVersions.h"
UsageAnn(..), mkUsgTy
)
import Unique ( Unique, mkPrimOpIdUnique )
-import BasicTypes ( Arity )
+import BasicTypes ( Arity, Boxity(..) )
import CStrings ( CLabelString, pprCLabelString )
-import PrelMods ( pREL_GHC, pREL_GHC_Name )
+import PrelNames ( pREL_GHC, pREL_GHC_Name )
import Outputable
import Util ( assoc, zipWithEqual )
import GlaExts ( Int(..), Int#, (==#) )
| TakeMVarOp
| PutMVarOp
| SameMVarOp
- | TakeMaybeMVarOp
+ | TryTakeMVarOp
| IsEmptyMVarOp
-- exceptions
tagOf_PrimOp TakeMVarOp = ILIT(218)
tagOf_PrimOp PutMVarOp = ILIT(219)
tagOf_PrimOp SameMVarOp = ILIT(220)
-tagOf_PrimOp TakeMaybeMVarOp = ILIT(221)
+tagOf_PrimOp TryTakeMVarOp = ILIT(221)
tagOf_PrimOp IsEmptyMVarOp = ILIT(222)
tagOf_PrimOp MkForeignObjOp = ILIT(223)
tagOf_PrimOp WriteForeignObjOp = ILIT(224)
TakeMVarOp,
PutMVarOp,
SameMVarOp,
- TakeMaybeMVarOp,
+ TryTakeMVarOp,
IsEmptyMVarOp,
MkForeignObjOp,
WriteForeignObjOp,
= [intPrimTy, byteArrayPrimTy, -- Integer
intPrimTy]
-unboxedPair = mkUnboxedTupleTy 2
-unboxedTriple = mkUnboxedTupleTy 3
-unboxedQuadruple = mkUnboxedTupleTy 4
+unboxedSingleton = mkTupleTy Unboxed 1
+unboxedPair = mkTupleTy Unboxed 2
+unboxedTriple = mkTupleTy Unboxed 3
+unboxedQuadruple = mkTupleTy Unboxed 4
mkIOTy ty = mkFunTy realWorldStatePrimTy
(unboxedPair [realWorldStatePrimTy,ty])
primOpInfo IndexArrayOp
= let { elt = alphaTy; elt_tv = alphaTyVar } in
mkGenPrimOp SLIT("indexArray#") [elt_tv] [mkArrayPrimTy elt, intPrimTy]
- (mkUnboxedTupleTy 1 [elt])
+ (unboxedSingleton [elt])
---------------------------------------------------------------------------
-- Primitive arrays full of unboxed bytes:
in
mkGenPrimOp SLIT("sameMVar#") [s_tv, elt_tv] [mvar_ty, mvar_ty] boolTy
-primOpInfo TakeMaybeMVarOp
+primOpInfo TryTakeMVarOp
= let
elt = alphaTy; elt_tv = alphaTyVar; s = betaTy; s_tv = betaTyVar
state = mkStatePrimTy s
in
- mkGenPrimOp SLIT("takeMaybeMVar#") [s_tv, elt_tv]
+ mkGenPrimOp SLIT("tryTakeMVar#") [s_tv, elt_tv]
[mkMVarPrimTy s elt, state]
(unboxedTriple [state, intPrimTy, elt])
primOpOutOfLine op
= case op of
TakeMVarOp -> True
- TakeMaybeMVarOp -> True
+ TryTakeMVarOp -> True
PutMVarOp -> True
DelayOp -> True
WaitReadOp -> True
primOpHasSideEffects UnsafeThawArrayOp = True
primOpHasSideEffects TakeMVarOp = True
-primOpHasSideEffects TakeMaybeMVarOp = True
+primOpHasSideEffects TryTakeMVarOp = True
primOpHasSideEffects PutMVarOp = True
primOpHasSideEffects DelayOp = True
primOpHasSideEffects WaitReadOp = True
TakeMVarOp -> mangle [mkM, mkP ] mkM
PutMVarOp -> mangle [mkM, mkM, mkP ] mkR
SameMVarOp -> mangle [mkP, mkP ] mkM
- TakeMaybeMVarOp -> mangle [mkM, mkP ] mkM
+ TryTakeMVarOp -> mangle [mkM, mkP ] mkM
IsEmptyMVarOp -> mangle [mkP, mkP ] mkM
ForkOp -> mangle [mkO, mkP ] mkR
Nothing -> pprPanic "primOpUsg:inFun" (ppr op <+> ppr ty)
inUB fs ty = case splitTyConApp_maybe ty of
- Just (tc,tys) -> ASSERT( tc == unboxedTupleTyCon (length fs) )
- mkUnboxedTupleTy (length fs) (zipWithEqual "primOpUsg"
+ Just (tc,tys) -> ASSERT( tc == tupleTyCon Unboxed (length fs) )
+ mkTupleTy Unboxed (length fs) (zipWithEqual "primOpUsg"
($) fs tys)
Nothing -> pprPanic "primOpUsg:inUB" (ppr op <+> ppr ty)
\end{code}
Bool -- True <=> really a "casm"
Bool -- True <=> might invoke Haskell GC
CallConv -- calling convention to use.
+ deriving( Eq )
data CCallTarget
= StaticTarget CLabelString -- An "unboxed" ccall# to `fn'.
-- the function pointer if compiling the ccall# down to
-- .hc code - can't do this inline for tedious reasons.)
+instance Eq CCallTarget where
+ (StaticTarget l1) == (StaticTarget l2) = l1 == l2
+ (DynamicTarget _) == (DynamicTarget _) = True
+ -- Ignore the arbitrary unique; this is important when comparing
+ -- a dynamic ccall read from an interface file A.hi with the
+ -- one constructed from A.hs, when deciding whether the interface
+ -- has changed
+ t1 == t2 = False
+
ccallMayGC :: CCall -> Bool
ccallMayGC (CCall _ _ may_gc _) = may_gc
ccallIsCasm :: CCall -> Bool
ccallIsCasm (CCall _ c_asm _ _) = c_asm
+
+isDynamicTarget (DynamicTarget _) = True
+isDynamicTarget (StaticTarget _) = False
+
+dynamicTarget :: CCallTarget
+dynamicTarget = DynamicTarget (panic "Unique in DynamicTarget not yet set")
+ -- The unique is really only to do with code generation, so it
+ -- is only set in CoreToStg; before then it's just an error message
+
+setCCallUnique :: CCall -> Unique -> CCall
+setCCallUnique (CCall (DynamicTarget _) is_asm may_gc cconv) uniq
+ = CCall (DynamicTarget uniq) is_asm may_gc cconv
+setCCallUnique ccall uniq = ccall
\end{code}
\begin{code}