\begin{code}
module ByteCodeGen ( UnlinkedBCO, UnlinkedBCOExpr, ItblEnv, ClosureEnv, HValue,
filterNameMap,
- byteCodeGen, coreExprToBCOs,
- linkIModules, linkIExpr
+ byteCodeGen, coreExprToBCOs
) where
#include "HsVersions.h"
import Outputable
-import Name ( Name, getName, mkSysLocalName )
-import Id ( Id, idType, isDataConId_maybe, mkVanillaId,
- isPrimOpId_maybe )
+import Name ( Name, getName )
+import Id ( Id, idType, isDataConId_maybe, isPrimOpId_maybe, isFCallId,
+ idPrimRep, mkSysLocal, idName )
import OrdList ( OrdList, consOL, snocOL, appOL, unitOL,
nilOL, toOL, concatOL, fromOL )
import FiniteMap ( FiniteMap, addListToFM, listToFM,
- addToFM, lookupFM, fmToList, plusFM )
+ addToFM, lookupFM, fmToList )
import CoreSyn
import PprCore ( pprCoreExpr )
import Literal ( Literal(..), literalPrimRep )
import PrimRep ( PrimRep(..) )
import PrimOp ( PrimOp(..) )
import CoreFVs ( freeVars )
-import Type ( typePrimRep )
-import DataCon ( dataConTag, fIRST_TAG, dataConTyCon, dataConWrapId )
-import TyCon ( TyCon, tyConFamilySize )
+import Type ( typePrimRep, splitTyConApp_maybe, isTyVarTy, splitForAllTys )
+import DataCon ( dataConTag, fIRST_TAG, dataConTyCon,
+ dataConWrapId, isUnboxedTupleCon )
+import TyCon ( TyCon(..), tyConFamilySize, isDataTyCon, tyConDataCons,
+ isFunTyCon )
import Class ( Class, classTyCon )
import Util ( zipEqual, zipWith4Equal, naturalMergeSortLe, nOfThem )
import Var ( isTyVar )
import ErrUtils ( showPass, dumpIfSet_dyn )
import Unique ( mkPseudoUnique3 )
import FastString ( FastString(..) )
+import Panic ( GhcException(..) )
import PprType ( pprType )
-import ByteCodeInstr ( BCInstr(..), ProtoBCO(..), nameOfProtoBCO )
+import ByteCodeInstr ( BCInstr(..), ProtoBCO(..), nameOfProtoBCO, bciStackUse )
import ByteCodeItbls ( ItblEnv, mkITbls )
import ByteCodeLink ( UnlinkedBCO, UnlinkedBCOExpr, assembleBCO,
- ClosureEnv, HValue, linkSomeBCOs, filterNameMap )
+ ClosureEnv, HValue, filterNameMap,
+ iNTERP_STACK_CHECK_THRESH )
-import List ( intersperse, sortBy )
+import List ( intersperse, sortBy, zip4 )
import Foreign ( Ptr(..), mallocBytes )
import Addr ( Addr(..), addrToInt, writeCharOffAddr )
import CTypes ( CInt )
+import Exception ( throwDyn )
import PrelBase ( Int(..) )
import PrelGHC ( ByteArray# )
-- create a totally bogus name for the top-level BCO; this
-- should be harmless, since it's never used for anything
- let invented_name = mkSysLocalName (mkPseudoUnique3 0) SLIT("Expr-Top-Level")
- let invented_id = mkVanillaId invented_name (panic "invented_id's type")
+ let invented_id = mkSysLocal SLIT("Expr-Top-Level") (mkPseudoUnique3 0)
+ (panic "invented_id's type")
+ let invented_name = idName invented_id
let (BcM_State all_proto_bcos final_ctr)
= runBc (BcM_State [] 0)
root_bco <- assembleBCO root_proto_bco
return (root_bco, auxiliary_bcos)
-
-
--- Linking stuff
-linkIModules :: ItblEnv -- incoming global itbl env; returned updated
- -> ClosureEnv -- incoming global closure env; returned updated
- -> [([UnlinkedBCO], ItblEnv)]
- -> IO ([HValue], ItblEnv, ClosureEnv)
-linkIModules gie gce mods
- = do let (bcoss, ies) = unzip mods
- bcos = concat bcoss
- final_gie = foldr plusFM gie ies
- (final_gce, linked_bcos) <- linkSomeBCOs final_gie gce bcos
- return (linked_bcos, final_gie, final_gce)
-
-
-linkIExpr :: ItblEnv -> ClosureEnv -> UnlinkedBCOExpr
- -> IO HValue -- IO BCO# really
-linkIExpr ie ce (root_ul_bco, aux_ul_bcos)
- = do (aux_ce, _) <- linkSomeBCOs ie ce aux_ul_bcos
- (_, [root_bco]) <- linkSomeBCOs ie aux_ce [root_ul_bco]
- return root_bco
\end{code}
%************************************************************************
-- Create a BCO and do a spot of peephole optimisation on the insns
-- at the same time.
mkProtoBCO nm instrs_ordlist origin
- = ProtoBCO nm (id {-peep-} (fromOL instrs_ordlist)) origin
+ = ProtoBCO nm maybe_with_stack_check origin
where
+ -- Overestimate the stack usage (in words) of this BCO,
+ -- and if >= iNTERP_STACK_CHECK_THRESH, add an explicit
+ -- stack check. (The interpreter always does a stack check
+ -- for iNTERP_STACK_CHECK_THRESH words at the start of each
+ -- BCO anyway, so we only need to add an explicit on in the
+ -- (hopefully rare) cases when the (overestimated) stack use
+ -- exceeds iNTERP_STACK_CHECK_THRESH.
+ maybe_with_stack_check
+ | stack_overest >= 65535
+ = pprPanic "mkProtoBCO: stack use won't fit in 16 bits"
+ (int stack_overest)
+ | stack_overest >= iNTERP_STACK_CHECK_THRESH
+ = (STKCHECK stack_overest) : peep_d
+ | otherwise
+ = peep_d -- the supposedly common case
+
+ stack_overest = sum (map bciStackUse peep_d)
+ + 10 {- just to be really really sure -}
+
+
+ -- Merge local pushes
+ peep_d = peep (fromOL instrs_ordlist)
+
peep (PUSH_L off1 : PUSH_L off2 : PUSH_L off3 : rest)
= PUSH_LLL off1 (off2-1) (off3-2) : peep rest
peep (PUSH_L off1 : PUSH_L off2 : rest)
- = PUSH_LL off1 off2 : peep rest
+ = PUSH_LL off1 (off2-1) : peep rest
peep (i:rest)
= i : peep rest
peep []
-- Delegate tail-calls to schemeT.
schemeE d s p e@(fvs, AnnApp f a)
- = returnBc (schemeT d s p (fvs, AnnApp f a))
+ = schemeT d s p (fvs, AnnApp f a)
schemeE d s p e@(fvs, AnnVar v)
| isFollowableRep v_rep
- = returnBc (schemeT d s p (fvs, AnnVar v))
+ = schemeT d s p (fvs, AnnVar v)
| otherwise
= -- returning an unboxed value. Heave it on the stack, SLIDE, and RETURN.
returnBc (allocCode `appOL` thunkCode `appOL` bodyCode)
+
+
+
+schemeE d s p (fvs_case, AnnCase (fvs_scrut, scrut) bndr
+ [(DEFAULT, [], (fvs_rhs, rhs))])
+
+ | let isFunType var_type
+ = case splitForAllTys var_type of
+ (_, ty) -> case splitTyConApp_maybe ty of
+ Just (tycon,_) | isFunTyCon tycon -> True
+ _ -> False
+ ty_bndr = idType bndr
+ in isFunType ty_bndr || isTyVarTy ty_bndr
+
+ -- Nasty hack; treat
+ -- case scrut::suspect of bndr { DEFAULT -> rhs }
+ -- as
+ -- let bndr = scrut in rhs
+ -- when suspect is polymorphic or arrowtyped
+ -- So the required strictness properties are not observed.
+ -- At some point, must fix this properly.
+ = let new_expr
+ = (fvs_case,
+ AnnLet
+ (AnnNonRec bndr (fvs_scrut, scrut)) (fvs_rhs, rhs)
+ )
+
+ in trace ("WARNING: ignoring polymorphic case in interpreted mode.\n" ++
+ " Possibly due to strict polymorphic/functional constructor args.\n" ++
+ " Your program may leak space unexpectedly.\n")
+ -- ++ showSDoc (char ' ' $$ pprCoreExpr (deAnnotate new_expr) $$ char ' '))
+ (schemeE d s p new_expr)
+
+
schemeE d s p (fvs, AnnCase scrut bndr alts)
= let
-- Top of stack is the return itbl, as usual.
scrut_primrep = typePrimRep (idType bndr)
isAlgCase
= case scrut_primrep of
- CharRep -> False ; AddrRep -> False
+ CharRep -> False ; AddrRep -> False ; WordRep -> False
IntRep -> False ; FloatRep -> False ; DoubleRep -> False
+ VoidRep -> False ;
PtrRep -> True
other -> pprPanic "ByteCodeGen.schemeE" (ppr other)
codeAlt alt@(discr, binds_f, rhs)
| isAlgCase
= let (unpack_code, d_after_unpack, p_after_unpack)
- = mkUnpackCode binds_f d' p'
+ = mkUnpackCode (filter (not.isTyVar) binds_f) d' p'
in schemeE d_after_unpack s p_after_unpack rhs
`thenBc` \ rhs_code ->
returnBc (my_discr alt, unpack_code `appOL` rhs_code)
schemeE d' s p' rhs `thenBc` \ rhs_code ->
returnBc (my_discr alt, rhs_code)
- my_discr (DEFAULT, binds, rhs) = NoDiscr
- my_discr (DataAlt dc, binds, rhs) = DiscrP (dataConTag dc - fIRST_TAG)
+ my_discr (DEFAULT, binds, rhs) = NoDiscr
+ my_discr (DataAlt dc, binds, rhs)
+ | isUnboxedTupleCon dc
+ = unboxedTupleException
+ | otherwise
+ = DiscrP (dataConTag dc - fIRST_TAG)
my_discr (LitAlt l, binds, rhs)
= case l of MachInt i -> DiscrI (fromInteger i)
MachFloat r -> DiscrF (fromRational r)
(pprCoreExpr (deAnnotate other))
--- Compile code to do a tail call. Three cases:
+-- Compile code to do a tail call. Specifically, push the fn,
+-- slide the on-stack app back down to the sequel depth,
+-- and enter. Four cases:
+--
+-- 0. (Nasty hack).
+-- An application "PrelGHC.tagToEnum# <type> unboxed-int".
+-- The int will be on the stack. Generate a code sequence
+-- to convert it to the relevant constructor, SLIDE and ENTER.
--
-- 1. A nullary constructor. Push its closure on the stack
-- and SLIDE and RETURN.
-> Sequel -- Sequel depth
-> BCEnv -- stack env
-> AnnExpr Id VarSet
- -> BCInstrList
+ -> BcM BCInstrList
schemeT d s p app
-- | trace ("schemeT: env in = \n" ++ showSDocDebug (ppBCEnv p)) False
-- = panic "schemeT ?!?!"
+ -- Handle case 0
+ | Just (arg, constr_names) <- maybe_is_tagToEnum_call
+ = pushAtom True d p arg `bind` \ (push, arg_words) ->
+ implement_tagToId constr_names `thenBc` \ tagToId_sequence ->
+ returnBc (push `appOL` tagToId_sequence
+ `appOL` mkSLIDE 1 (d+arg_words-s)
+ `snocOL` ENTER)
+
-- Handle case 1
| is_con_call && null args_r_to_l
- = (PUSH_G (Left (getName con)) `consOL` mkSLIDE 1 (d-s))
- `snocOL` ENTER
+ = returnBc (
+ (PUSH_G (Left (getName con)) `consOL` mkSLIDE 1 (d-s))
+ `snocOL` ENTER
+ )
-- Cases 2 and 3
| otherwise
- = code
+ = if is_con_call && isUnboxedTupleCon con
+ then returnBc unboxedTupleException
+ else returnBc code
- where
- -- Extract the args (R->L) and fn
- (args_r_to_l_raw, fn) = chomp app
- chomp expr
- = case snd expr of
- AnnVar v -> ([], v)
- AnnApp f a -> case chomp f of (az, f) -> (snd a:az, f)
- other -> pprPanic "schemeT"
- (ppr (deAnnotate (panic "schemeT.chomp", other)))
+ where
+ -- Detect and extract relevant info for the tagToEnum kludge.
+ maybe_is_tagToEnum_call
+ = let extract_constr_Names ty
+ = case splitTyConApp_maybe ty of
+ (Just (tyc, [])) | isDataTyCon tyc
+ -> map getName (tyConDataCons tyc)
+ other -> panic "maybe_is_tagToEnum_call.extract_constr_Ids"
+ in
+ case app of
+ (_, AnnApp (_, AnnApp (_, AnnVar v) (_, AnnType t)) arg)
+ -> case isPrimOpId_maybe v of
+ Just TagToEnumOp -> Just (snd arg, extract_constr_Names t)
+ other -> Nothing
+ other -> Nothing
+
+ -- Extract the args (R->L) and fn
+ (args_r_to_l_raw, fn) = chomp app
+ chomp expr
+ = case snd expr of
+ AnnVar v -> ([], v)
+ AnnApp f a -> case chomp f of (az, f) -> (snd a:az, f)
+ AnnNote n e -> chomp e
+ other -> pprPanic "schemeT"
+ (ppr (deAnnotate (panic "schemeT.chomp", other)))
- args_r_to_l = filter (not.isTypeAtom) args_r_to_l_raw
- isTypeAtom (AnnType _) = True
- isTypeAtom _ = False
-
- -- decide if this is a constructor call, and rearrange
- -- args appropriately.
- maybe_dcon = isDataConId_maybe fn
- is_con_call = case maybe_dcon of Nothing -> False; Just _ -> True
- (Just con) = maybe_dcon
-
- args_final_r_to_l
- | not is_con_call
- = args_r_to_l
- | otherwise
- = filter (not.isPtr) args_r_to_l ++ filter isPtr args_r_to_l
- where isPtr = isFollowableRep . atomRep
-
- -- make code to push the args and then do the SLIDE-ENTER thing
- code = do_pushery d args_final_r_to_l
-
- tag_when_push = not is_con_call
- narg_words = sum (map (get_arg_szw . atomRep) args_r_to_l)
- get_arg_szw = if tag_when_push then taggedSizeW else untaggedSizeW
-
- do_pushery d (arg:args)
- = let (push, arg_words) = pushAtom tag_when_push d p arg
- in push `appOL` do_pushery (d+arg_words) args
- do_pushery d []
- = case maybe_dcon of
- Just con -> PACK con narg_words `consOL` (
- mkSLIDE 1 (d - narg_words - s) `snocOL` ENTER)
- Nothing
- -> let (push, arg_words) = pushAtom True d p (AnnVar fn)
- in push
- `appOL` mkSLIDE (narg_words+arg_words)
- (d - s - narg_words)
- `snocOL` ENTER
+ args_r_to_l = filter (not.isTypeAtom) args_r_to_l_raw
+ isTypeAtom (AnnType _) = True
+ isTypeAtom _ = False
+
+ -- decide if this is a constructor call, and rearrange
+ -- args appropriately.
+ maybe_dcon = isDataConId_maybe fn
+ is_con_call = case maybe_dcon of Nothing -> False; Just _ -> True
+ (Just con) = maybe_dcon
+
+ args_final_r_to_l
+ | not is_con_call
+ = args_r_to_l
+ | otherwise
+ = filter (not.isPtr) args_r_to_l ++ filter isPtr args_r_to_l
+ where isPtr = isFollowableRep . atomRep
+
+ -- make code to push the args and then do the SLIDE-ENTER thing
+ code = do_pushery d args_final_r_to_l
+
+ tag_when_push = not is_con_call
+ narg_words = sum (map (get_arg_szw . atomRep) args_r_to_l)
+ get_arg_szw = if tag_when_push then taggedSizeW else untaggedSizeW
+
+ do_pushery d (arg:args)
+ = let (push, arg_words) = pushAtom tag_when_push d p arg
+ in push `appOL` do_pushery (d+arg_words) args
+ do_pushery d []
+ = case maybe_dcon of
+ Just con -> PACK con narg_words `consOL` (
+ mkSLIDE 1 (d - narg_words - s) `snocOL` ENTER)
+ Nothing
+ -> let (push, arg_words) = pushAtom True d p (AnnVar fn)
+ in push
+ `appOL` mkSLIDE (narg_words+arg_words)
+ (d - s - narg_words)
+ `snocOL` ENTER
mkSLIDE n d
= if d == 0 then nilOL else unitOL (SLIDE n d)
+bind x f
+ = f x
+
atomRep (AnnVar v) = typePrimRep (idType v)
atomRep (AnnLit l) = literalPrimRep l
atomRep (AnnNote n b) = atomRep (snd b)
atomRep (AnnApp f (_, AnnType _)) = atomRep (snd f)
+atomRep (AnnLam x e) | isTyVar x = atomRep (snd e)
atomRep other = pprPanic "atomRep" (ppr (deAnnotate (undefined,other)))
+-- Compile code which expects an unboxed Int on the top of stack,
+-- (call it i), and pushes the i'th closure in the supplied list
+-- as a consequence.
+implement_tagToId :: [Name] -> BcM BCInstrList
+implement_tagToId names
+ = ASSERT(not (null names))
+ getLabelsBc (length names) `thenBc` \ labels ->
+ getLabelBc `thenBc` \ label_fail ->
+ getLabelBc `thenBc` \ label_exit ->
+ zip4 labels (tail labels ++ [label_fail])
+ [0 ..] names `bind` \ infos ->
+ map (mkStep label_exit) infos `bind` \ steps ->
+ returnBc (concatOL steps
+ `appOL`
+ toOL [LABEL label_fail, CASEFAIL, LABEL label_exit])
+ where
+ mkStep l_exit (my_label, next_label, n, name_for_n)
+ = toOL [LABEL my_label,
+ TESTEQ_I n next_label,
+ PUSH_G (Left name_for_n),
+ JMP l_exit]
+
+
-- Make code to unpack the top-of-stack constructor onto the stack,
-- adding tags for the unboxed bits. Takes the PrimReps of the
-- constructor's arguments. off_h and off_s are travelling offsets
pushAtom :: Bool -> Int -> BCEnv -> AnnExpr' Id VarSet -> (BCInstrList, Int)
pushAtom tagged d p (AnnVar v)
+
+ | idPrimRep v == VoidRep
+ = ASSERT(tagged)
+ (unitOL (PUSH_TAG 0), 1)
+
+ | isFCallId v
+ = pprPanic "pushAtom: byte code generator can't handle CCalls" (ppr v)
+
| Just primop <- isPrimOpId_maybe v
- = case primop of
- CCallOp _ -> panic "pushAtom: byte code generator can't handle CCalls"
- other -> (unitOL (PUSH_G (Right primop)), 1)
+ = (unitOL (PUSH_G (Right primop)), 1)
| otherwise
- = let str = "\npushAtom " ++ showSDocDebug (ppr v)
+ = let {-
+ str = "\npushAtom " ++ showSDocDebug (ppr v)
++ " :: " ++ showSDocDebug (pprType (idType v))
++ ", depth = " ++ show d
++ ", tagged = " ++ show tagged ++ ", env =\n" ++
++ " --> words: " ++ show (snd result) ++ "\n" ++
showSDoc (nest 4 (vcat (map ppr (fromOL (fst result)))))
++ "\nendPushAtom " ++ showSDocDebug (ppr v)
- where
- cmp_snd x y = compare (snd x) (snd y)
- str' = if str == str then str else str
+ -}
result
= case lookupBCEnv_maybe p v of
sz_u = untaggedIdSizeW v
nwords = if tagged then sz_t else sz_u
in
- --trace str'
result
pushAtom True d p (AnnLit lit)
pushAtom False d p (AnnLit lit)
= case lit of
+ MachWord w -> code WordRep
MachInt i -> code IntRep
MachFloat r -> code FloatRep
MachDouble r -> code DoubleRep
pushAtom tagged d p (AnnNote note e)
= pushAtom tagged d p (snd e)
+pushAtom tagged d p (AnnLam x e)
+ | isTyVar x
+ = pushAtom tagged d p (snd e)
+
pushAtom tagged d p other
= pprPanic "ByteCodeGen.pushAtom"
(pprCoreExpr (deAnnotate (undefined, other)))
taggedIdSizeW = taggedSizeW . typePrimRep . idType
untaggedIdSizeW = untaggedSizeW . typePrimRep . idType
+unboxedTupleException :: a
+unboxedTupleException
+ = throwDyn
+ (Panic
+ ("Bytecode generator can't handle unboxed tuples. Possibly due\n" ++
+ "\tto foreign import/export decls in source. Workaround:\n" ++
+ "\tcompile this module to a .o file, then restart session."))
+
\end{code}
%************************************************************************
getLabelBc st
= (nextlabel st, st{nextlabel = 1 + nextlabel st})
+getLabelsBc :: Int -> BcM [Int]
+getLabelsBc n st
+ = let ctr = nextlabel st
+ in ([ctr .. ctr+n-1], st{nextlabel = ctr+n})
+
\end{code}