#include "HsVersions.h"
import Outputable
-import Name ( Name, getName, nameModule )
-import Id ( Id, idType, isDataConId_maybe )
+import Name ( Name, getName, nameModule, mkSysLocalName, toRdrName )
+import RdrName ( rdrNameOcc, rdrNameModule )
+import OccName ( occNameString )
+import Id ( Id, idType, isDataConId_maybe, mkVanillaId )
import OrdList ( OrdList, consOL, snocOL, appOL, unitOL,
nilOL, toOL, concatOL, fromOL )
import FiniteMap ( FiniteMap, addListToFM, listToFM, filterFM,
addToFM, lookupFM, fmToList, emptyFM, plusFM )
import CoreSyn
import PprCore ( pprCoreExpr, pprCoreAlt )
-import Literal ( Literal(..) )
+import Literal ( Literal(..), literalPrimRep )
import PrimRep ( PrimRep(..) )
import CoreFVs ( freeVars )
import Type ( typePrimRep )
import CmdLineOpts ( DynFlags, DynFlag(..) )
import ErrUtils ( showPass, dumpIfSet_dyn )
import ClosureInfo ( mkVirtHeapOffsets )
-import Module ( ModuleName, moduleName )
+import Module ( ModuleName, moduleName, moduleNameFS )
+import Unique ( mkPseudoUnique3 )
+import Linker ( lookupSymbol )
+import FastString ( FastString(..) )
+
import List ( intersperse )
import Monad ( foldM )
import ST ( runST )
-import MArray ( MArray(..), IOArray, IOUArray, HasBounds(..), freeze,
- mapArray, castSTUArray,
+import MArray ( castSTUArray,
newFloatArray, writeFloatArray,
- newDoubleArray, writeDoubleArray,
+ newDoubleArray, writeDoubleArray,
newIntArray, writeIntArray,
newAddrArray, writeAddrArray )
import Foreign ( Storable(..), Word8, Word16, Word32, Ptr(..),
- malloc, castPtr, plusPtr )
-import Addr ( Word, Addr, addrToInt, nullAddr )
+ malloc, castPtr, plusPtr, mallocBytes )
+import Addr ( Word, addrToInt, nullAddr, writeCharOffAddr )
import Bits ( Bits(..), shiftR )
+import CTypes ( CInt )
-import PrelGHC ( BCO#, newBCO#, unsafeCoerce#, ByteArray#, Array# )
-import IOExts ( IORef, readIORef, writeIORef, fixIO )
+import PrelBase ( Int(..) )
+import PrelAddr ( Addr(..) )
+import PrelGHC ( BCO#, newBCO#, unsafeCoerce#,
+ ByteArray#, Array#, addrToHValue# )
+import IOExts ( IORef, fixIO, unsafePerformIO )
import ArrayBase
import PrelArr ( Array(..) )
import PrelIOBase ( IO(..) )
-> IO UnlinkedBCOExpr
coreExprToBCOs dflags expr
= do showPass dflags "ByteCodeGen"
- let invented_id = panic "invented_id" :: Id
- (BcM_State all_proto_bcos final_ctr)
+
+ -- 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 (BcM_State all_proto_bcos final_ctr)
= runBc (BcM_State [] 0)
(schemeR (invented_id, freeVars expr))
- dumpIfSet_dyn dflags Opt_D_dump_InterpSyn
+ dumpIfSet_dyn dflags Opt_D_dump_BCOs
"Proto-bcos" (vcat (intersperse (char ' ') (map ppr all_proto_bcos)))
- let invented_name = getName invented_id
let root_proto_bco
= case filter ((== invented_name).nameOfProtoBCO) all_proto_bcos of
[root_bco] -> root_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
+
+-- Link a bunch of BCOs and return them + updated closure env.
+linkSomeBCOs :: ItblEnv -> ClosureEnv -> [UnlinkedBCO]
+ -> IO (ClosureEnv, [HValue])
+linkSomeBCOs ie ce_in ul_bcos
+ = do let nms = map nameOfUnlinkedBCO ul_bcos
+ hvals <- fixIO
+ ( \ hvs -> let ce_out = addListToFM ce_in (zipLazily nms hvs)
+ in mapM (linkBCO ie ce_out) ul_bcos )
+ let ce_out = addListToFM ce_in (zip nms hvals)
+ return (ce_out, hvals)
+ where
+ -- A lazier zip, in which no demand is propagated to the second
+ -- list unless some demand is propagated to the snd of one of the
+ -- result list elems.
+ zipLazily [] ys = []
+ zipLazily (x:xs) ys = (x, head ys) : zipLazily xs (tail ys)
data UnlinkedBCO
= UnlinkedBCO Name
- Int (IOUArray Int Word16) -- insns
- Int (IOUArray Int Word) -- literals
- Int (IOArray Int Name) -- ptrs
- Int (IOArray Int Name) -- itbl refs
+ (SizedSeq Word16) -- insns
+ (SizedSeq Word) -- literals
+ (SizedSeq Name) -- ptrs
+ (SizedSeq Name) -- itbl refs
-nameOfUnlinkedBCO (UnlinkedBCO nm _ _ _ _ _ _ _ _) = nm
+nameOfUnlinkedBCO (UnlinkedBCO nm _ _ _ _) = nm
-- When translating expressions, we need to distinguish the root
-- BCO for the expression
type UnlinkedBCOExpr = (UnlinkedBCO, [UnlinkedBCO])
instance Outputable UnlinkedBCO where
- ppr (UnlinkedBCO nm n_insns insns n_lits lits n_ptrs ptrs n_itbls itbls)
+ ppr (UnlinkedBCO nm insns lits ptrs itbls)
= sep [text "BCO", ppr nm, text "with",
- int n_insns, text "insns",
- int n_lits, text "lits",
- int n_ptrs, text "ptrs",
- int n_itbls, text "itbls"]
+ int (sizeSS insns), text "insns",
+ int (sizeSS lits), text "lits",
+ int (sizeSS ptrs), text "ptrs",
+ int (sizeSS itbls), text "itbls"]
-- these need a proper home
type LocalLabel = Int
-data UnboxedLit = UnboxedI Int | UnboxedF Float | UnboxedD Double
-
data BCInstr
-- Messing with the stack
= ARGCHECK Int
-- Pushing literals
| PUSH_UBX Literal Int
-- push this int/float/double, NO TAG, on the stack
- -- Int is # of items in literal pool to push
+ -- Int is # of words to copy from literal pool
| PUSH_TAG Int -- push this tag on the stack
| SLIDE Int{-this many-} Int{-down by this much-}
| TESTEQ_F Float LocalLabel
| TESTLT_D Double LocalLabel
| TESTEQ_D Double LocalLabel
+
+ -- The Int value is a constructor number and therefore
+ -- stored in the insn stream rather than as an offset into
+ -- the literal pool.
| TESTLT_P Int LocalLabel
| TESTEQ_P Int LocalLabel
+
| CASEFAIL
-- To Infinity And Beyond
| ENTER
- | RETURN -- unboxed value on TOS. Use tag to find underlying ret itbl
+ | RETURN PrimRep
+ -- unboxed value on TOS. Use tag to find underlying ret itbl
-- and return as per that.
ppr (PUSH_LLL o1 o2 o3) = text "PUSH_LLL" <+> int o1 <+> int o2 <+> int o3
ppr (PUSH_G nm) = text "PUSH_G " <+> ppr nm
ppr (PUSH_AS nm pk) = text "PUSH_AS " <+> ppr nm <+> ppr pk
+ ppr (PUSH_UBX lit nw) = text "PUSH_UBX" <+> parens (int nw) <+> ppr lit
+ ppr (PUSH_TAG n) = text "PUSH_TAG" <+> int n
ppr (SLIDE n d) = text "SLIDE " <+> int n <+> int d
ppr (ALLOC sz) = text "ALLOC " <+> int sz
- ppr (MKAP offset sz) = text "MKAP " <+> int offset <+> int sz
+ ppr (MKAP offset sz) = text "MKAP " <+> int sz <+> text "words,"
+ <+> int offset <+> text "stkoff"
ppr (UNPACK sz) = text "UNPACK " <+> int sz
+ ppr (UPK_TAG n m k) = text "UPK_TAG " <+> int n <> text "words"
+ <+> int m <> text "conoff"
+ <+> int k <> text "stkoff"
ppr (PACK dcon sz) = text "PACK " <+> ppr dcon <+> ppr sz
ppr (LABEL lab) = text "__" <> int lab <> colon
ppr (TESTLT_I i lab) = text "TESTLT_I" <+> int i <+> text "__" <> int lab
ppr (TESTEQ_P i lab) = text "TESTEQ_P" <+> int i <+> text "__" <> int lab
ppr CASEFAIL = text "CASEFAIL"
ppr ENTER = text "ENTER"
- ppr RETURN = text "RETURN"
-
-pprAltCode discrs_n_codes
- = vcat (map f discrs_n_codes)
- where f (discr, code) = ppr discr <> colon <+> vcat (map ppr (fromOL code))
+ ppr (RETURN pk) = text "RETURN " <+> ppr pk
instance Outputable a => Outputable (ProtoBCO a) where
ppr (ProtoBCO name instrs origin)
-- Create a BCO and do a spot of peephole optimisation on the insns
-- at the same time.
mkProtoBCO nm instrs_ordlist origin
- = ProtoBCO nm (peep (fromOL instrs_ordlist)) origin
+ = ProtoBCO nm (id {-peep-} (fromOL instrs_ordlist)) origin
where
peep (PUSH_L off1 : PUSH_L off2 : PUSH_L off3 : rest)
= PUSH_LLL off1 (off2-1) (off3-2) : peep rest
-- variable to which this value was bound, so as to give the
-- resulting BCO a name.
schemeR :: (Id, AnnExpr Id VarSet) -> BcM ()
-schemeR (nm, rhs) = schemeR_wrk rhs nm (collect [] rhs)
+schemeR (nm, rhs)
+{-
+ | trace (showSDoc (
+ (char ' '
+ $$ (ppr.filter (not.isTyVar).varSetElems.fst) rhs
+ $$ pprCoreExpr (deAnnotate rhs)
+ $$ char ' '
+ ))) False
+ = undefined
+-}
+ | otherwise
+ = schemeR_wrk rhs nm (collect [] rhs)
+
collect xs (_, AnnLam x e)
= collect (if isTyVar x then xs else (x:xs)) e
szsw_args = map taggedIdSizeW all_args
szw_args = sum szsw_args
p_init = listToFM (zip all_args (mkStackOffsets 0 szsw_args))
- argcheck = if null args then nilOL else unitOL (ARGCHECK szw_args)
+ argcheck = {-if null args then nilOL else-} unitOL (ARGCHECK szw_args)
in
schemeE szw_args 0 p_init body `thenBc` \ body_code ->
emitBc (mkProtoBCO (getName nm) (appOL argcheck body_code) (Right original_body))
schemeE d s p e@(fvs, AnnApp f a)
= returnBc (schemeT (should_args_be_tagged e) d s 0 p (fvs, AnnApp f a))
schemeE d s p e@(fvs, AnnVar v)
- | isFollowableRep (typePrimRep (idType v))
+ | isFollowableRep v_rep
= returnBc (schemeT (should_args_be_tagged e) d s 0 p (fvs, AnnVar v))
| otherwise
= -- returning an unboxed value. Heave it on the stack, SLIDE, and RETURN.
let (push, szw) = pushAtom True d p (AnnVar v)
in returnBc (push -- value onto stack
`snocOL` SLIDE szw (d-s) -- clear to sequel
- `snocOL` RETURN) -- go
+ `snocOL` RETURN v_rep) -- go
+ where
+ v_rep = typePrimRep (idType v)
schemeE d s p (fvs, AnnLit literal)
= let (push, szw) = pushAtom True d p (AnnLit literal)
+ l_rep = literalPrimRep literal
in returnBc (push -- value onto stack
`snocOL` SLIDE szw (d-s) -- clear to sequel
- `snocOL` RETURN) -- go
+ `snocOL` RETURN l_rep) -- go
schemeE d s p (fvs, AnnLet binds b)
= let (xs,rhss) = case binds of AnnNonRec x rhs -> ([x],[rhs])
AnnRec xs_n_rhss -> unzip xs_n_rhss
n = length xs
fvss = map (filter (not.isTyVar).varSetElems.fst) rhss
+
+ -- Sizes of tagged free vars, + 1 for the fn
sizes = map (\rhs_fvs -> 1 + sum (map taggedIdSizeW rhs_fvs)) fvss
-- This p', d' defn is safe because all the items being pushed
returnBc (my_discr alt, rhs_code)
my_discr (DEFAULT, binds, rhs) = NoDiscr
- my_discr (DataAlt dc, binds, rhs) = DiscrP (dataConTag dc)
+ my_discr (DataAlt dc, binds, rhs) = DiscrP (dataConTag dc - fIRST_TAG)
my_discr (LitAlt l, binds, rhs)
= case l of MachInt i -> DiscrI (fromInteger i)
MachFloat r -> DiscrF (fromRational r)
mapBc codeAlt alts `thenBc` \ alt_stuff ->
mkMultiBranch maybe_ncons alt_stuff `thenBc` \ alt_final ->
let
+ alt_final_ac = ARGCHECK (taggedIdSizeW bndr) `consOL` alt_final
alt_bco_name = getName bndr
- alt_bco = mkProtoBCO alt_bco_name alt_final (Left alts)
+ alt_bco = mkProtoBCO alt_bco_name alt_final_ac (Left alts)
in
schemeE (d + ret_frame_sizeW)
(d + ret_frame_sizeW) p scrut `thenBc` \ scrut_code ->
schemeT enTag d s narg_words p (_, AnnVar f)
| Just con <- isDataConId_maybe f
= ASSERT(enTag == False)
- PACK con narg_words `consOL` (mkSLIDE 1 (d-s-1) `snocOL` ENTER)
+ --trace ("schemeT: d = " ++ show d ++ ", s = " ++ show s ++ ", naw = " ++ show narg_words) (
+ PACK con narg_words `consOL` (mkSLIDE 1 (d - narg_words - s) `snocOL` ENTER)
+ --)
| otherwise
= ASSERT(enTag == True)
let (push, arg_words) = pushAtom True d p (AnnVar f)
Just d_v -> (toOL (nOfThem nwords (PUSH_L (d-d_v+sz_t-2))), sz_t)
Nothing -> ASSERT(sz_t == 1) (unitOL (PUSH_G nm), sz_t)
- nm = getName v
+ nm = case isDataConId_maybe v of
+ Just c -> getName c
+ Nothing -> getName v
+
sz_t = taggedIdSizeW v
sz_u = untaggedIdSizeW v
nwords = if tagged then sz_t else sz_u
MachInt i -> code IntRep
MachFloat r -> code FloatRep
MachDouble r -> code DoubleRep
+ MachChar c -> code CharRep
+ MachStr s -> pushStr s
where
code rep
= let size_host_words = untaggedSizeW rep
in (unitOL (PUSH_UBX lit size_host_words), size_host_words)
+ pushStr s
+ = let mallocvilleAddr
+ = case s of
+ CharStr s i -> A# s
+
+ FastString _ l ba ->
+ -- sigh, a string in the heap is no good to us.
+ -- We need a static C pointer, since the type of
+ -- a string literal is Addr#. So, copy the string
+ -- into C land and introduce a memory leak
+ -- at the same time.
+ let n = I# l
+ -- CAREFUL! Chars are 32 bits in ghc 4.09+
+ in unsafePerformIO (
+ do a@(Ptr addr) <- mallocBytes (n+1)
+ strncpy a ba (fromIntegral n)
+ writeCharOffAddr addr n '\0'
+ return addr
+ )
+ _ -> panic "StgInterp.lit2expr: unhandled string constant type"
+
+ addrLit
+ = MachInt (toInteger (addrToInt mallocvilleAddr))
+ in
+ -- Get the addr on the stack, untaggedly
+ (unitOL (PUSH_UBX addrLit 1), 1)
+
+
+
+
+
pushAtom tagged d p (AnnApp f (_, AnnType _))
= pushAtom tagged d p (snd f)
= pprPanic "ByteCodeGen.pushAtom"
(pprCoreExpr (deAnnotate (undefined, other)))
+foreign import "strncpy" strncpy :: Ptr a -> ByteArray# -> CInt -> IO ()
+
-- Given a bunch of alts code and their discrs, do the donkey work
-- of making a multiway branch using a switch tree.
(algMinBound, algMaxBound)
= case maybe_ncons of
- Just n -> (fIRST_TAG, fIRST_TAG + n - 1)
+ Just n -> (0, n - 1)
Nothing -> (minBound, maxBound)
(DiscrI i1) `eqAlt` (DiscrI i2) = i1 == i2
-- Find things in the BCEnv (the what's-on-the-stack-env)
-- See comment preceding pushAtom for precise meaning of env contents
-lookupBCEnv :: BCEnv -> Id -> Int
-lookupBCEnv env nm
- = case lookupFM env nm of
- Nothing -> pprPanic "lookupBCEnv"
- (ppr nm $$ char ' ' $$ vcat (map ppr (fmToList env)))
- Just xx -> xx
+--lookupBCEnv :: BCEnv -> Id -> Int
+--lookupBCEnv env nm
+-- = case lookupFM env nm of
+-- Nothing -> pprPanic "lookupBCEnv"
+-- (ppr nm $$ char ' ' $$ vcat (map ppr (fmToList env)))
+-- Just xx -> xx
lookupBCEnv_maybe :: BCEnv -> Id -> Maybe Int
lookupBCEnv_maybe = lookupFM
type BcM result = BcM_State -> (result, BcM_State)
-mkBcM_State :: [ProtoBCO Name] -> Int -> BcM_State
-mkBcM_State = BcM_State
-
runBc :: BcM_State -> BcM () -> BcM_State
runBc init_st m = case m init_st of { (r,st) -> st }
assembleBCO (ProtoBCO nm instrs origin)
= let
- -- pass 1: collect up the offsets of the local labels
- label_env = mkLabelEnv emptyFM 0 instrs
+ -- pass 1: collect up the offsets of the local labels.
+ -- Remember that the first insn starts at offset 1 since offset 0
+ -- (eventually) will hold the total # of insns.
+ label_env = mkLabelEnv emptyFM 1 instrs
mkLabelEnv env i_offset [] = env
mkLabelEnv env i_offset (i:is)
= let new_env
= case i of LABEL n -> addToFM env n i_offset ; _ -> env
- in mkLabelEnv new_env (i_offset + instrSizeB i) is
+ in mkLabelEnv new_env (i_offset + instrSize16s i) is
findLabel lab
= case lookupFM label_env lab of
Just bco_offset -> bco_offset
Nothing -> pprPanic "assembleBCO.findLabel" (int lab)
-
- init_n_insns = 10
- init_n_lits = 4
- init_n_ptrs = 4
- init_n_itbls = 4
in
- do insns <- newXIOUArray init_n_insns :: IO (XIOUArray Word16)
- lits <- newXIOUArray init_n_lits :: IO (XIOUArray Word)
- ptrs <- newXIOArray init_n_ptrs -- :: IO (XIOArray Name)
- itbls <- newXIOArray init_n_itbls -- :: IO (XIOArray Name)
-
- -- pass 2: generate the instruction, ptr and nonptr bits
+ do -- pass 2: generate the instruction, ptr and nonptr bits
+ insns <- return emptySS :: IO (SizedSeq Word16)
+ lits <- return emptySS :: IO (SizedSeq Word)
+ ptrs <- return emptySS :: IO (SizedSeq Name)
+ itbls <- return emptySS :: IO (SizedSeq Name)
let init_asm_state = (insns,lits,ptrs,itbls)
- final_asm_state <- mkBits findLabel init_asm_state instrs
-
- -- unwrap the expandable arrays
- let final_insns = stuffXIOU insns
- final_lits = stuffXIOU lits
- final_ptrs = stuffXIO ptrs
- final_itbls = stuffXIO itbls
-
- return (UnlinkedBCO nm
- (usedXIOU insns) final_insns
- (usedXIOU lits) final_lits
- (usedXIO ptrs) final_ptrs
- (usedXIO itbls) final_itbls)
+ (final_insns, final_lits, final_ptrs, final_itbls)
+ <- mkBits findLabel init_asm_state instrs
+ return (UnlinkedBCO nm final_insns final_lits final_ptrs final_itbls)
-- instrs nonptrs ptrs itbls
-type AsmState = (XIOUArray Word16, XIOUArray Word, XIOArray Name, XIOArray Name)
+type AsmState = (SizedSeq Word16, SizedSeq Word, SizedSeq Name, SizedSeq Name)
+
+data SizedSeq a = SizedSeq !Int [a]
+emptySS = SizedSeq 0 []
+addToSS (SizedSeq n r_xs) x = return (SizedSeq (n+1) (x:r_xs))
+addListToSS (SizedSeq n r_xs) xs
+ = return (SizedSeq (n + length xs) (reverse xs ++ r_xs))
+sizeSS (SizedSeq n r_xs) = n
+listFromSS (SizedSeq n r_xs) = return (reverse r_xs)
-- This is where all the action is (pass 2 of the assembler)
PUSH_G nm -> do (p, st2) <- ptr st nm
instr2 st2 i_PUSH_G p
PUSH_AS nm pk -> do (p, st2) <- ptr st nm
- (np, st3) <- ret_itbl st2 pk
+ (np, st3) <- ctoi_itbl st2 pk
instr3 st3 i_PUSH_AS p np
- PUSH_UBX lit nw32s -> do (np, st2) <- literal st lit
- instr3 st2 i_PUSH_UBX np nw32s
+ PUSH_UBX lit nws -> do (np, st2) <- literal st lit
+ instr3 st2 i_PUSH_UBX np nws
PUSH_TAG tag -> instr2 st i_PUSH_TAG tag
SLIDE n by -> instr3 st i_SLIDE n by
ALLOC n -> instr2 st i_ALLOC n
instr3 st2 i_TESTLT_D np (findLabel l)
TESTEQ_D d l -> do (np, st2) <- double st d
instr3 st2 i_TESTEQ_D np (findLabel l)
- TESTLT_P i l -> do (np, st2) <- int st i
- instr3 st2 i_TESTLT_P np (findLabel l)
- TESTEQ_P i l -> do (np, st2) <- int st i
- instr3 st2 i_TESTEQ_P np (findLabel l)
+ TESTLT_P i l -> instr3 st i_TESTLT_P i (findLabel l)
+ TESTEQ_P i l -> instr3 st i_TESTEQ_P i (findLabel l)
CASEFAIL -> instr1 st i_CASEFAIL
ENTER -> instr1 st i_ENTER
- RETURN -> instr1 st i_RETURN
+ RETURN rep -> do (itbl_no,st2) <- itoc_itbl st rep
+ instr2 st2 i_RETURN itbl_no
i2s :: Int -> Word16
i2s = fromIntegral
instr1 (st_i0,st_l0,st_p0,st_I0) i1
- = do st_i1 <- addToXIOUArray st_i0 (i2s i1)
+ = do st_i1 <- addToSS st_i0 (i2s i1)
return (st_i1,st_l0,st_p0,st_I0)
instr2 (st_i0,st_l0,st_p0,st_I0) i1 i2
- = do st_i1 <- addToXIOUArray st_i0 (i2s i1)
- st_i2 <- addToXIOUArray st_i1 (i2s i2)
+ = do st_i1 <- addToSS st_i0 (i2s i1)
+ st_i2 <- addToSS st_i1 (i2s i2)
return (st_i2,st_l0,st_p0,st_I0)
instr3 (st_i0,st_l0,st_p0,st_I0) i1 i2 i3
- = do st_i1 <- addToXIOUArray st_i0 (i2s i1)
- st_i2 <- addToXIOUArray st_i1 (i2s i2)
- st_i3 <- addToXIOUArray st_i2 (i2s i3)
+ = do st_i1 <- addToSS st_i0 (i2s i1)
+ st_i2 <- addToSS st_i1 (i2s i2)
+ st_i3 <- addToSS st_i2 (i2s i3)
return (st_i3,st_l0,st_p0,st_I0)
instr4 (st_i0,st_l0,st_p0,st_I0) i1 i2 i3 i4
- = do st_i1 <- addToXIOUArray st_i0 (i2s i1)
- st_i2 <- addToXIOUArray st_i1 (i2s i2)
- st_i3 <- addToXIOUArray st_i2 (i2s i3)
- st_i4 <- addToXIOUArray st_i3 (i2s i4)
+ = do st_i1 <- addToSS st_i0 (i2s i1)
+ st_i2 <- addToSS st_i1 (i2s i2)
+ st_i3 <- addToSS st_i2 (i2s i3)
+ st_i4 <- addToSS st_i3 (i2s i4)
return (st_i4,st_l0,st_p0,st_I0)
float (st_i0,st_l0,st_p0,st_I0) f
- = do let w32s = mkLitF f
- st_l1 <- addListToXIOUArray st_l0 w32s
- return (usedXIOU st_l0, (st_i0,st_l1,st_p0,st_I0))
+ = do let ws = mkLitF f
+ st_l1 <- addListToSS st_l0 ws
+ return (sizeSS st_l0, (st_i0,st_l1,st_p0,st_I0))
double (st_i0,st_l0,st_p0,st_I0) d
- = do let w32s = mkLitD d
- st_l1 <- addListToXIOUArray st_l0 w32s
- return (usedXIOU st_l0, (st_i0,st_l1,st_p0,st_I0))
+ = do let ws = mkLitD d
+ st_l1 <- addListToSS st_l0 ws
+ return (sizeSS st_l0, (st_i0,st_l1,st_p0,st_I0))
int (st_i0,st_l0,st_p0,st_I0) i
- = do let w32s = mkLitI i
- st_l1 <- addListToXIOUArray st_l0 w32s
- return (usedXIOU st_l0, (st_i0,st_l1,st_p0,st_I0))
+ = do let ws = mkLitI i
+ st_l1 <- addListToSS st_l0 ws
+ return (sizeSS st_l0, (st_i0,st_l1,st_p0,st_I0))
addr (st_i0,st_l0,st_p0,st_I0) a
- = do let w32s = mkLitA a
- st_l1 <- addListToXIOUArray st_l0 w32s
- return (usedXIOU st_l0, (st_i0,st_l1,st_p0,st_I0))
+ = do let ws = mkLitA a
+ st_l1 <- addListToSS st_l0 ws
+ return (sizeSS st_l0, (st_i0,st_l1,st_p0,st_I0))
ptr (st_i0,st_l0,st_p0,st_I0) p
- = do st_p1 <- addToXIOArray st_p0 p
- return (usedXIO st_p0, (st_i0,st_l0,st_p1,st_I0))
+ = do st_p1 <- addToSS st_p0 p
+ return (sizeSS st_p0, (st_i0,st_l0,st_p1,st_I0))
itbl (st_i0,st_l0,st_p0,st_I0) dcon
- = do st_I1 <- addToXIOArray st_I0 (getName dcon)
- return (usedXIO st_I0, (st_i0,st_l0,st_p0,st_I1))
+ = do st_I1 <- addToSS st_I0 (getName dcon)
+ return (sizeSS st_I0, (st_i0,st_l0,st_p0,st_I1))
literal st (MachInt j) = int st (fromIntegral j)
literal st (MachFloat r) = float st (fromRational r)
literal st (MachDouble r) = double st (fromRational r)
+ literal st (MachChar c) = int st c
- ret_itbl st pk
+ ctoi_itbl st pk
= addr st ret_itbl_addr
where
- ret_itbl_addr
- = case pk of
- IntRep -> stg_ctoi_ret_R1_info
- FloatRep -> stg_ctoi_ret_F1_info
- DoubleRep -> stg_ctoi_ret_D1_info
- where -- TEMP HACK
- stg_ctoi_ret_F1_info = nullAddr
- stg_ctoi_ret_D1_info = nullAddr
+ ret_itbl_addr = case pk of
+ PtrRep -> stg_ctoi_ret_R1_info
+ IntRep -> stg_ctoi_ret_R1_info
+ FloatRep -> stg_ctoi_ret_F1_info
+ DoubleRep -> stg_ctoi_ret_D1_info
+ _ -> pprPanic "mkBits.ctoi_itbl" (ppr pk)
+ where -- TEMP HACK
+ stg_ctoi_ret_F1_info = nullAddr
+ stg_ctoi_ret_D1_info = nullAddr
+
+ itoc_itbl st pk
+ = addr st ret_itbl_addr
+ where
+ ret_itbl_addr = case pk of
+ IntRep -> stg_gc_unbx_r1_info
+ FloatRep -> stg_gc_f1_info
+ DoubleRep -> stg_gc_d1_info
foreign label "stg_ctoi_ret_R1_info" stg_ctoi_ret_R1_info :: Addr
--foreign label "stg_ctoi_ret_F1_info" stg_ctoi_ret_F1_info :: Addr
--foreign label "stg_ctoi_ret_D1_info" stg_ctoi_ret_D1_info :: Addr
--- The size in bytes of an instruction.
-instrSizeB :: BCInstr -> Int
-instrSizeB instr
+foreign label "stg_gc_unbx_r1_info" stg_gc_unbx_r1_info :: Addr
+foreign label "stg_gc_f1_info" stg_gc_f1_info :: Addr
+foreign label "stg_gc_d1_info" stg_gc_d1_info :: Addr
+
+-- The size in 16-bit entities of an instruction.
+instrSize16s :: BCInstr -> Int
+instrSize16s instr
= case instr of
- ARGCHECK _ -> 4
- PUSH_L _ -> 4
- PUSH_LL _ _ -> 6
- PUSH_LLL _ _ _ -> 8
- PUSH_G _ -> 4
- SLIDE _ _ -> 6
- ALLOC _ -> 4
- MKAP _ _ -> 6
- UNPACK _ -> 4
- PACK _ _ -> 6
- LABEL _ -> 4
- TESTLT_I _ _ -> 6
- TESTEQ_I _ _ -> 6
- TESTLT_F _ _ -> 6
- TESTEQ_F _ _ -> 6
- TESTLT_D _ _ -> 6
- TESTEQ_D _ _ -> 6
- TESTLT_P _ _ -> 6
- TESTEQ_P _ _ -> 6
- CASEFAIL -> 2
- ENTER -> 2
- RETURN -> 2
+ ARGCHECK _ -> 2
+ PUSH_L _ -> 2
+ PUSH_LL _ _ -> 3
+ PUSH_LLL _ _ _ -> 4
+ PUSH_G _ -> 2
+ PUSH_AS _ _ -> 3
+ PUSH_UBX _ _ -> 3
+ PUSH_TAG _ -> 2
+ SLIDE _ _ -> 3
+ ALLOC _ -> 2
+ MKAP _ _ -> 3
+ UNPACK _ -> 2
+ UPK_TAG _ _ _ -> 4
+ PACK _ _ -> 3
+ LABEL _ -> 0 -- !!
+ TESTLT_I _ _ -> 3
+ TESTEQ_I _ _ -> 3
+ TESTLT_F _ _ -> 3
+ TESTEQ_F _ _ -> 3
+ TESTLT_D _ _ -> 3
+ TESTEQ_D _ _ -> 3
+ TESTLT_P _ _ -> 3
+ TESTEQ_P _ _ -> 3
+ CASEFAIL -> 1
+ ENTER -> 1
+ RETURN _ -> 2
-- Make lists of host-sized words for literals, so that when the
return [w0]
)
-
--- Zero-based expandable arrays
-data XIOUArray ele
- = XIOUArray { usedXIOU :: Int, stuffXIOU :: (IOUArray Int ele) }
-data XIOArray ele
- = XIOArray { usedXIO :: Int , stuffXIO :: (IOArray Int ele) }
-
-newXIOUArray size
- = do arr <- newArray (0, size-1)
- return (XIOUArray 0 arr)
-
-addListToXIOUArray xarr []
- = return xarr
-addListToXIOUArray xarr (x:xs)
- = addToXIOUArray xarr x >>= \ xarr' -> addListToXIOUArray xarr' xs
-
-
-addToXIOUArray :: MArray IOUArray a IO
- => XIOUArray a -> a -> IO (XIOUArray a)
-addToXIOUArray (XIOUArray n_arr arr) x
- = case bounds arr of
- (lo, hi) -> ASSERT(lo == 0)
- if n_arr > hi
- then do new_arr <- newArray (0, 2*hi-1)
- copy hi arr new_arr
- addToXIOUArray (XIOUArray n_arr new_arr) x
- else do writeArray arr n_arr x
- return (XIOUArray (n_arr+1) arr)
- where
- copy :: MArray IOUArray a IO
- => Int -> IOUArray Int a -> IOUArray Int a -> IO ()
- copy n src dst
- | n < 0 = return ()
- | otherwise = do nx <- readArray src n
- writeArray dst n nx
- copy (n-1) src dst
-
-
-
-newXIOArray size
- = do arr <- newArray (0, size-1)
- return (XIOArray 0 arr)
-
-addToXIOArray :: XIOArray a -> a -> IO (XIOArray a)
-addToXIOArray (XIOArray n_arr arr) x
- = case bounds arr of
- (lo, hi) -> ASSERT(lo == 0)
- if n_arr > hi
- then do new_arr <- newArray (0, 2*hi-1)
- copy hi arr new_arr
- addToXIOArray (XIOArray n_arr new_arr) x
- else do writeArray arr n_arr x
- return (XIOArray (n_arr+1) arr)
- where
- copy :: Int -> IOArray Int a -> IOArray Int a -> IO ()
- copy n src dst
- | n < 0 = return ()
- | otherwise = do nx <- readArray src n
- writeArray dst n nx
- copy (n-1) src dst
-
\end{code}
%************************************************************************
\begin{code}
{-
-data UnlinkedBCO
- = UnlinkedBCO Int (IOUArray Int Word16) -- #insns insns
- Int (IOUArray Int Word32) -- #literals literals
- Int (IOArray Int Name) -- #ptrs ptrs
- Int (IOArray Int Name) -- #itblrefs itblrefs
-
data BCO# = BCO# ByteArray# -- instrs :: array Word16#
ByteArray# -- literals :: array Word32#
PtrArray# -- ptrs :: Array HValue
ByteArray# -- itbls :: Array Addr#
-}
-data LinkedBCO = LinkedBCO BCO#
-
-
-
GLOBAL_VAR(v_cafTable, [], [HValue])
-addCAF :: HValue -> IO ()
-addCAF x = do xs <- readIORef v_cafTable; writeIORef v_cafTable (x:xs)
+--addCAF :: HValue -> IO ()
+--addCAF x = do xs <- readIORef v_cafTable; writeIORef v_cafTable (x:xs)
-bcosToHValue :: ItblEnv -> ClosureEnv -> UnlinkedBCOExpr -> IO HValue
-bcosToHValue ie ce (root_bco, other_bcos)
- = do linked_expr <- linkIExpr ie ce (root_bco, other_bcos)
- return linked_expr
+--bcosToHValue :: ItblEnv -> ClosureEnv -> UnlinkedBCOExpr -> IO HValue
+--bcosToHValue ie ce (root_bco, other_bcos)
+-- = do linked_expr <- linkIExpr ie ce (root_bco, other_bcos)
+-- return linked_expr
+linkBCO ie ce (UnlinkedBCO nm insnsSS literalsSS ptrsSS itblsSS)
+ = do insns <- listFromSS insnsSS
+ literals <- listFromSS literalsSS
+ ptrs <- listFromSS ptrsSS
+ itbls <- listFromSS itblsSS
-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
- top_level_binders = map nameOfUnlinkedBCO bcos
- final_gie = foldr plusFM gie ies
-
- (new_bcos, new_gce) <-
- fixIO (\ ~(new_bcos, new_gce) -> do
- new_bcos <- linkBCOs final_gie new_gce bcos
- let new_gce = addListToFM gce (zip top_level_binders new_bcos)
- return (new_bcos, new_gce))
+ linked_ptrs <- mapM (lookupCE ce) ptrs
+ linked_itbls <- mapM (lookupIE ie) itbls
- return (new_bcos, final_gie, new_gce)
+ let n_insns = sizeSS insnsSS
+ n_literals = sizeSS literalsSS
+ n_ptrs = sizeSS ptrsSS
+ n_itbls = sizeSS itblsSS
+ let ptrs_arr = array (0, n_ptrs-1) (indexify linked_ptrs)
+ :: Array Int HValue
+ ptrs_parr = case ptrs_arr of Array lo hi parr -> parr
-linkIExpr :: ItblEnv -> ClosureEnv -> UnlinkedBCOExpr
- -> IO HValue -- IO BCO# really
-linkIExpr ie ce (root_ul_bco, aux_ul_bcos)
- = do let aux_ul_binders = map nameOfUnlinkedBCO aux_ul_bcos
- (aux_bcos, aux_ce)
- <- fixIO
- (\ ~(aux_bcos, new_ce)
- -> do new_bcos <- linkBCOs ie new_ce aux_ul_bcos
- let new_ce = addListToFM ce (zip aux_ul_binders new_bcos)
- return (new_bcos, new_ce)
- )
- [root_bco]
- <- linkBCOs ie aux_ce [root_ul_bco]
- return root_bco
-
+ itbls_arr = array (0, n_itbls-1) (indexify linked_itbls)
+ :: UArray Int Addr
+ itbls_barr = case itbls_arr of UArray lo hi barr -> barr
-linkBCOs :: ItblEnv -> ClosureEnv -> [UnlinkedBCO]
- -> IO [HValue] -- IO [BCO#] really
-linkBCOs ie ce binds = mapM (linkBCO ie ce) binds
+ insns_arr | n_insns > 65535
+ = panic "linkBCO: >= 64k insns in BCO"
+ | otherwise
+ = array (0, n_insns)
+ (indexify (fromIntegral n_insns:insns))
+ :: UArray Int Word16
+ insns_barr = case insns_arr of UArray lo hi barr -> barr
-linkBCO ie ce (UnlinkedBCO nm
- n_insns insns n_literals literals
- n_ptrs ptrs n_itbls itbls)
- = do linked_ptrs <- mapArray (lookupCE ce) ptrs
- linked_itbls <- mapArray (lookupIE ie) itbls
+ literals_arr = array (0, n_literals-1) (indexify literals)
+ :: UArray Int Word
+ literals_barr = case literals_arr of UArray lo hi barr -> barr
- ptrs_froz <- freeze linked_ptrs
- let ptrs_parr = case ptrs_froz of Array lo hi parr -> parr
-
- insns_froz <- freeze insns
- let insns_barr = case insns_froz of UArray lo hi barr -> barr
-
- literals_froz <- freeze literals
- let literals_barr = case literals_froz of UArray lo hi barr -> barr
-
- itbls_froz <- freeze linked_itbls
- let itbls_barr = case itbls_froz of UArray lo hi barr -> barr
+ indexify :: [a] -> [(Int, a)]
+ indexify xs = zip [0..] xs
BCO bco# <- newBCO insns_barr literals_barr ptrs_parr itbls_barr
-
+
return (unsafeCoerce# bco#)
+
data BCO = BCO BCO#
newBCO :: ByteArray# -> ByteArray# -> Array# a -> ByteArray# -> IO BCO
-newBCO a b c d = IO (\s -> case newBCO# a b c d s of (# s1, bco #) -> (# s1, BCO bco #))
+newBCO a b c d
+ = IO (\s -> case newBCO# a b c d s of (# s1, bco #) -> (# s1, BCO bco #))
-lookupCE :: ClosureEnv -> Name -> HValue
+lookupCE :: ClosureEnv -> Name -> IO HValue
lookupCE ce nm
= case lookupFM ce nm of
- Just aa -> unsafeCoerce# aa
- Nothing -> pprPanic "ByteCodeGen.lookupCE" (ppr nm)
-
-lookupIE :: ItblEnv -> Name -> Addr
-lookupIE ie nm
- = case lookupFM ie nm of
- Just (Ptr a) -> a
- Nothing -> pprPanic "ByteCodeGen.lookupIE" (ppr nm)
-
-
-
-{-
-lookupCon ie con =
- case lookupFM ie con of
- Just (Ptr addr) -> return addr
- Nothing -> do
- -- try looking up in the object files.
- m <- lookupSymbol (nameToCLabel con "con_info")
- case m of
- Just addr -> return addr
- Nothing -> pprPanic "linkIExpr" (ppr con)
-
--- nullary constructors don't have normal _con_info tables.
-lookupNullaryCon ie con =
- case lookupFM ie con of
- Just (Ptr addr) -> return (ConApp addr)
- Nothing -> do
- -- try looking up in the object files.
- m <- lookupSymbol (nameToCLabel con "closure")
- case m of
- Just (A# addr) -> return (Native (unsafeCoerce# addr))
- Nothing -> pprPanic "lookupNullaryCon" (ppr con)
-
-
-lookupNative ce var =
- unsafeInterleaveIO (do
- case lookupFM ce var of
- Just e -> return (Native e)
- Nothing -> do
- -- try looking up in the object files.
- let lbl = (nameToCLabel var "closure")
- m <- lookupSymbol lbl
- case m of
- Just (A# addr)
- -> do addCAF (unsafeCoerce# addr)
- return (Native (unsafeCoerce# addr))
- Nothing -> pprPanic "linkIExpr" (ppr var)
- )
-
--- some VarI/VarP refer to top-level interpreted functions; we change
--- them into Natives here.
-lookupVar ce f v =
- unsafeInterleaveIO (
- case lookupFM ce (getName v) of
- Nothing -> return (f v)
- Just e -> return (Native e)
- )
+ Just aa -> return aa
+ Nothing
+ -> do m <- lookupSymbol (nameToCLabel nm "closure")
+ case m of
+ Just (A# addr) -> case addrToHValue# addr of
+ (# hval #) -> return hval
+ Nothing -> pprPanic "ByteCodeGen.lookupCE" (ppr nm)
+
+lookupIE :: ItblEnv -> Name -> IO Addr
+lookupIE ie con_nm
+ = case lookupFM ie con_nm of
+ Just (Ptr a) -> return a
+ Nothing
+ -> do -- try looking up in the object files.
+ m <- lookupSymbol (nameToCLabel con_nm "con_info")
+ case m of
+ Just addr -> return addr
+ Nothing
+ -> do -- perhaps a nullary constructor?
+ n <- lookupSymbol (nameToCLabel con_nm "static_info")
+ case n of
+ Just addr -> return addr
+ Nothing -> pprPanic "ByteCodeGen.lookupIE" (ppr con_nm)
-- HACK!!! ToDo: cleaner
nameToCLabel :: Name -> String{-suffix-} -> String
-nameToCLabel n suffix =
- _UNPK_(moduleNameFS (rdrNameModule rn))
- ++ '_':occNameString(rdrNameOcc rn) ++ '_':suffix
- where rn = toRdrName n
--}
+nameToCLabel n suffix
+ = _UNPK_(moduleNameFS (rdrNameModule rn))
+ ++ '_':occNameString(rdrNameOcc rn) ++ '_':suffix
+ where rn = toRdrName n
+
\end{code}
%************************************************************************
mkITbl :: TyCon -> IO ItblEnv
mkITbl tc
--- | trace ("TYCON: " ++ showSDoc (ppr tc)) False
--- = error "?!?!"
| not (isDataTyCon tc)
= return emptyFM
| n == length dcs -- paranoia; this is an assertion.
-data Constructor = Constructor Int{-ptrs-} Int{-nptrs-}
-- Ultra-minimalist version specially for constructors
i_UNPACK = (bci_UNPACK :: Int)
i_UPK_TAG = (bci_UPK_TAG :: Int)
i_PACK = (bci_PACK :: Int)
-i_LABEL = (bci_LABEL :: Int)
i_TESTLT_I = (bci_TESTLT_I :: Int)
i_TESTEQ_I = (bci_TESTEQ_I :: Int)
i_TESTLT_F = (bci_TESTLT_F :: Int)