Commit 620d885b authored by Simon Marlow's avatar Simon Marlow
Browse files

expand tabs

parent a7c0387d
......@@ -10,21 +10,21 @@
-- back in circularly (to avoid a two-pass algorithm).
module StgCmmExtCode (
CmmParse(..),
CmmParse(..),
Named(..), Env,
loopDecls,
getEnv,
loopDecls,
getEnv,
newLocal,
newLocal,
newLabel,
newBlockId,
newFunctionName,
newImport,
lookupLabel,
lookupName,
newFunctionName,
newImport,
lookupLabel,
lookupName,
code,
code,
emit, emitLabel, emitAssign, emitStore,
getCode, getCodeR,
emitOutOfLine,
......@@ -50,28 +50,28 @@ import Unique
-- | The environment contains variable definitions or blockids.
data Named
= VarN CmmExpr -- ^ Holds CmmLit(CmmLabel ..) which gives the label type,
-- eg, RtsLabel, ForeignLabel, CmmLabel etc.
data Named
= VarN CmmExpr -- ^ Holds CmmLit(CmmLabel ..) which gives the label type,
-- eg, RtsLabel, ForeignLabel, CmmLabel etc.
| FunN PackageId -- ^ A function name from this package
| LabelN BlockId -- ^ A blockid of some code or data.
| FunN PackageId -- ^ A function name from this package
| LabelN BlockId -- ^ A blockid of some code or data.
-- | An environment of named things.
type Env = UniqFM Named
type Env = UniqFM Named
-- | Local declarations that are in scope during code generation.
type Decls = [(FastString,Named)]
type Decls = [(FastString,Named)]
-- | Does a computation in the FCode monad, with a current environment
-- and a list of local declarations. Returns the resulting list of declarations.
newtype CmmParse a
= EC { unEC :: Env -> Decls -> FCode (Decls, a) }
-- and a list of local declarations. Returns the resulting list of declarations.
newtype CmmParse a
= EC { unEC :: Env -> Decls -> FCode (Decls, a) }
type ExtCode = CmmParse ()
returnExtFC :: a -> CmmParse a
returnExtFC a = EC $ \_ s -> return (s, a)
returnExtFC a = EC $ \_ s -> return (s, a)
thenExtFC :: CmmParse a -> (a -> CmmParse b) -> CmmParse b
thenExtFC (EC m) k = EC $ \e s -> do (s',r) <- m e s; unEC (k r) e s'
......@@ -86,41 +86,41 @@ instance HasDynFlags CmmParse where
-- | Takes the variable decarations and imports from the monad
-- and makes an environment, which is looped back into the computation.
-- In this way, we can have embedded declarations that scope over the whole
-- procedure, and imports that scope over the entire module.
-- Discards the local declaration contained within decl'
-- and makes an environment, which is looped back into the computation.
-- In this way, we can have embedded declarations that scope over the whole
-- procedure, and imports that scope over the entire module.
-- Discards the local declaration contained within decl'
--
loopDecls :: CmmParse a -> CmmParse a
loopDecls (EC fcode) =
EC $ \e globalDecls -> do
(_, a) <- F.fixC (\ ~(decls, _) -> fcode (addListToUFM e (decls ++ globalDecls)) globalDecls)
return (globalDecls, a)
return (globalDecls, a)
-- | Get the current environment from the monad.
getEnv :: CmmParse Env
getEnv = EC $ \e s -> return (s, e)
getEnv = EC $ \e s -> return (s, e)
-- | Add a new variable to the list of local declarations.
-- The CmmExpr says where the value is stored.
-- The CmmExpr says where the value is stored.
addVarDecl :: FastString -> CmmExpr -> ExtCode
addVarDecl var expr
= EC $ \_ s -> return ((var, VarN expr):s, ())
= EC $ \_ s -> return ((var, VarN expr):s, ())
-- | Add a new label to the list of local declarations.
addLabel :: FastString -> BlockId -> ExtCode
addLabel name block_id
= EC $ \_ s -> return ((name, LabelN block_id):s, ())
= EC $ \_ s -> return ((name, LabelN block_id):s, ())
-- | Create a fresh local variable of a given type.
newLocal
:: CmmType -- ^ data type
-> FastString -- ^ name of variable
-> CmmParse LocalReg -- ^ register holding the value
:: CmmType -- ^ data type
-> FastString -- ^ name of variable
-> CmmParse LocalReg -- ^ register holding the value
newLocal ty name = do
u <- code newUnique
let reg = LocalReg u ty
......@@ -140,56 +140,56 @@ newBlockId = code F.newLabelC
-- | Add add a local function to the environment.
newFunctionName
:: FastString -- ^ name of the function
-> PackageId -- ^ package of the current module
-> ExtCode
:: FastString -- ^ name of the function
-> PackageId -- ^ package of the current module
-> ExtCode
newFunctionName name pkg
= EC $ \_ s -> return ((name, FunN pkg):s, ())
= EC $ \_ s -> return ((name, FunN pkg):s, ())
-- | Add an imported foreign label to the list of local declarations.
-- If this is done at the start of the module the declaration will scope
-- over the whole module.
-- If this is done at the start of the module the declaration will scope
-- over the whole module.
newImport
:: (FastString, CLabel)
-> CmmParse ()
:: (FastString, CLabel)
-> CmmParse ()
newImport (name, cmmLabel)
= addVarDecl name (CmmLit (CmmLabel cmmLabel))
-- | Lookup the BlockId bound to the label with this name.
-- If one hasn't been bound yet, create a fresh one based on the
-- Unique of the name.
-- If one hasn't been bound yet, create a fresh one based on the
-- Unique of the name.
lookupLabel :: FastString -> CmmParse BlockId
lookupLabel name = do
env <- getEnv
return $
case lookupUFM env name of
Just (LabelN l) -> l
_other -> mkBlockId (newTagUnique (getUnique name) 'L')
Just (LabelN l) -> l
_other -> mkBlockId (newTagUnique (getUnique name) 'L')
-- | Lookup the location of a named variable.
-- Unknown names are treated as if they had been 'import'ed from the runtime system.
-- This saves us a lot of bother in the RTS sources, at the expense of
-- deferring some errors to link time.
-- Unknown names are treated as if they had been 'import'ed from the runtime system.
-- This saves us a lot of bother in the RTS sources, at the expense of
-- deferring some errors to link time.
lookupName :: FastString -> CmmParse CmmExpr
lookupName name = do
env <- getEnv
return $
case lookupUFM env name of
Just (VarN e) -> e
Just (FunN pkg) -> CmmLit (CmmLabel (mkCmmCodeLabel pkg name))
_other -> CmmLit (CmmLabel (mkCmmCodeLabel rtsPackageId name))
Just (VarN e) -> e
Just (FunN pkg) -> CmmLit (CmmLabel (mkCmmCodeLabel pkg name))
_other -> CmmLit (CmmLabel (mkCmmCodeLabel rtsPackageId name))
-- | Lift an FCode computation into the CmmParse monad
code :: FCode a -> CmmParse a
code fc = EC $ \_ s -> do
r <- fc
return (s, r)
r <- fc
return (s, r)
emit :: CmmAGraph -> CmmParse ()
emit = code . F.emit
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment